intershell 0.3.0

package/src/entities/compose/compose.ts

@@ -0,0 +1,251 @@
+import { EntityAffected } from "../affected";
+import { EntityPackage } from "../package";
+import type {
+	ComposeData,
+	ComposeValidationResult,
+	EntityAffectedService,
+	NetworkDefinition,
+	PortMapping,
+	ServiceDefinition,
+	ServiceDependencyGraph,
+	ServiceHealth,
+	ServiceInfo,
+	VolumeDefinition,
+} from "./compose.types";
+
+type TemporaryBunYamlTypeSinceThisIsNotTypedYet = {
+	YAML: {
+		parse: (input: string) => Record<string, unknown>;
+	};
+};
+
+const allPackages = await EntityPackage.getAllPackages();
+
+export class EntityCompose {
+	private readonly composePath: string;
+	private compose: ComposeData | undefined;
+
+	constructor(composePath: string) {
+		this.composePath = composePath;
+	}
+
+	async validate(): Promise<ComposeValidationResult> {
+		const compose = await this.getCompose();
+		const errors = [];
+
+		if (!compose.services || Object.keys(compose.services).length === 0) {
+			errors.push({
+				code: "NO_SERVICES",
+				message: "At least one service must be defined",
+			});
+		}
+
+		// Check each service has required configuration
+		for (const [name, service] of Object.entries(compose.services)) {
+			if (!service.image && !service.build) {
+				errors.push({
+					code: "NO_IMAGE_OR_BUILD",
+					message: "Service must have either image or build configuration",
+					service: name,
+				});
+			}
+		}
+
+		return {
+			isValid: errors.length === 0,
+			errors,
+		};
+	}
+
+	async getCompose(): Promise<ComposeData> {
+		this.compose =
+			this.compose || EntityCompose.parseDockerCompose(await Bun.file(this.composePath).text());
+		return this.compose;
+	}
+
+	async getServices(): Promise<ServiceInfo[]> {
+		const compose = await this.getCompose();
+		const services: ServiceInfo[] = [];
+
+		for (const [name, service] of Object.entries(compose.services)) {
+			const ports = EntityCompose.parsePortMappings(service.ports || []);
+			const environment = EntityCompose.parseEnvironment(service.environment);
+
+			services.push({
+				name,
+				image: service.image,
+				ports,
+				environment,
+				volumes: service.volumes || [],
+				dependencies: service.depends_on || [],
+				health: {
+					name,
+					status: "unknown",
+					checks: 0,
+					failures: 0,
+				},
+			});
+		}
+
+		return services;
+	}
+
+	async getServiceHealth(): Promise<ServiceHealth[]> {
+		const compose = await this.getCompose();
+		return Object.keys(compose.services).map((name) => ({
+			name,
+			status: "healthy" as const,
+			checks: 10,
+			failures: 0,
+			lastCheck: new Date(),
+		}));
+	}
+
+	async getServiceDependencies(): Promise<ServiceDependencyGraph> {
+		const compose = await this.getCompose();
+		const services = Object.keys(compose.services);
+		const dependencies: Record<string, string[]> = {};
+
+		for (const [name, service] of Object.entries(compose.services)) {
+			dependencies[name] = service.depends_on || [];
+		}
+
+		return {
+			services,
+			dependencies,
+		};
+	}
+
+	async getServiceUrls(): Promise<Record<string, string>> {
+		const mappings = await this.getPortMappings();
+		return Object.fromEntries(mappings.map((m) => [m.host, `http://localhost:${m.host}`]));
+	}
+
+	async getPortMappings(): Promise<PortMapping[]> {
+		const compose = await this.getCompose();
+		const mappings: PortMapping[] = [];
+
+		for (const service of Object.values(compose.services)) {
+			if (service.ports) {
+				mappings.push(...EntityCompose.parsePortMappings(service.ports));
+			}
+		}
+
+		return mappings;
+	}
+
+	async getAffectedServices(baseSha?: string, to?: string): Promise<EntityAffectedService[]> {
+		try {
+			const keys = await EntityAffected.getAffectedPackages(baseSha, to);
+			const serviceMap = new Map<string, EntityAffectedService>();
+			const affectedServices = new Set<string>();
+
+			const services = await this.getServices();
+
+			// Find services associated with affected packages
+			for (const service of services) {
+				const associatedPackage = allPackages.find(
+					(p) => p.replace(/^@repo\//, "") === service.name,
+				);
+
+				if (keys.some((k: string) => k === associatedPackage)) {
+					affectedServices.add(service.name);
+					serviceMap.set(service.name, {
+						name: service.name,
+						port: service.ports[0]?.host,
+					});
+
+					// Add dependencies
+					if (service.dependencies) {
+						for (const dep of service.dependencies) {
+							affectedServices.add(dep);
+						}
+					}
+				}
+			}
+
+			// Add all affected services to the map
+			for (const serviceName of affectedServices) {
+				if (!serviceMap.has(serviceName)) {
+					const devService = services.find((s) => s.name === serviceName);
+					if (devService) {
+						serviceMap.set(serviceName, {
+							name: devService.name,
+							port: devService.ports[0]?.host,
+						});
+					}
+				}
+			}
+
+			return Array.from(serviceMap.values());
+		} catch (error) {
+			throw new Error(`Failed to get affected services: ${error}`);
+		}
+	}
+
+	static parseDockerCompose(input: string): ComposeData {
+		const parsed = (Bun as unknown as TemporaryBunYamlTypeSinceThisIsNotTypedYet).YAML.parse(input);
+
+		if (parsed.services) {
+			for (const [, service] of Object.entries(parsed.services)) {
+				if (service.ports && Array.isArray(service.ports)) {
+					(service as Record<string, unknown>).ports = service.ports.map((port: unknown) =>
+						typeof port === "string" ? port : String(port),
+					);
+				}
+
+				if (service.environment && Array.isArray(service.environment)) {
+					const envObj: Record<string, string> = {};
+					for (const env of service.environment) {
+						if (typeof env === "string" && env.includes("=")) {
+							const [key, ...valueParts] = env.split("=");
+							envObj[key] = valueParts.join("=");
+						}
+					}
+					(service as Record<string, unknown>).environment = envObj;
+				}
+			}
+		}
+
+		return {
+			version: (parsed.version as string) || "3.8",
+			services: (parsed.services as Record<string, ServiceDefinition>) || {},
+			networks: (parsed.networks as Record<string, NetworkDefinition>) || {},
+			volumes: (parsed.volumes as Record<string, VolumeDefinition>) || {},
+			validation: {
+				isValid: true,
+				errors: [],
+			},
+		};
+	}
+
+	public static parsePortMappings(ports: string[]): PortMapping[] {
+		return ports.map((port) => {
+			const [host, container] = port.split(":").map(Number);
+			return {
+				host: host ?? container,
+				container: container ?? host,
+				protocol: "tcp" as const,
+			};
+		});
+	}
+
+	public static parseEnvironment(env?: Record<string, string> | string[]): Record<string, string> {
+		if (!env) return {};
+
+		if (Array.isArray(env)) {
+			const result: Record<string, string> = {};
+			for (const item of env) {
+				if (typeof item === "string" && item.includes("=")) {
+					const [key, ...valueParts] = item.split("=");
+					if (key && valueParts.length > 0) {
+						result[key] = valueParts.join("=");
+					}
+				}
+			}
+			return result;
+		}
+
+		return env;
+	}
+}

package/src/entities/compose/compose.types.ts

@@ -0,0 +1,88 @@
+export interface ComposeData {
+	readonly version: string;
+	readonly services: Record<string, ServiceDefinition>;
+	readonly networks: Record<string, NetworkDefinition>;
+	readonly volumes: Record<string, VolumeDefinition>;
+	readonly validation: ComposeValidationResult;
+}
+
+export interface ServiceDefinition {
+	readonly image?: string;
+	readonly build?: string | BuildDefinition;
+	readonly ports?: string[];
+	readonly environment?: Record<string, string> | string[];
+	readonly volumes?: string[];
+	readonly depends_on?: string[];
+	readonly networks?: string[];
+	readonly restart?: string;
+	readonly command?: string | string[];
+	readonly entrypoint?: string | string[];
+}
+
+export interface BuildDefinition {
+	readonly context: string;
+	readonly dockerfile?: string;
+	readonly args?: Record<string, string>;
+}
+
+export interface NetworkDefinition {
+	readonly driver?: string;
+	readonly external?: boolean;
+}
+
+export interface VolumeDefinition {
+	readonly driver?: string;
+	readonly external?: boolean;
+}
+
+export interface ServiceInfo {
+	readonly name: string;
+	readonly image?: string;
+	readonly ports: PortMapping[];
+	readonly environment: Record<string, string>;
+	readonly volumes: string[];
+	readonly dependencies: string[];
+	readonly health: ServiceHealth;
+}
+
+export interface PortMapping {
+	readonly host: number;
+	readonly container: number;
+	readonly protocol: "tcp" | "udp";
+}
+
+export interface ServiceHealth {
+	readonly name: string;
+	readonly status: "healthy" | "unhealthy" | "starting" | "unknown";
+	readonly checks: number;
+	readonly failures: number;
+	readonly lastCheck?: Date;
+}
+
+export interface ServiceDependencyGraph {
+	readonly services: string[];
+	readonly dependencies: Record<string, string[]>;
+}
+
+export interface PortConflict {
+	readonly port: number;
+	readonly services: string[];
+	readonly severity: "error" | "warning";
+}
+
+export interface EntityAffectedService {
+	readonly name: string;
+	readonly port?: number;
+}
+
+export interface ComposeValidationResult {
+	readonly isValid: boolean;
+	readonly errors: ComposeValidationError[];
+}
+
+export interface ComposeValidationError {
+	readonly code: string;
+	readonly message: string;
+	readonly service?: string;
+	readonly field?: string;
+}

package/src/entities/compose/index.ts

@@ -0,0 +1,2 @@
+export * from "./compose";
+export * from "./compose.types";

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

@@ -0,0 +1,35 @@
+import { expect, mock, test } from "bun:test";
+import type { $ } from "bun";
+
+test("entitiesShell should be defined", async () => {
+	const { entitiesShell } = await import("./entities.shell");
+	expect(entitiesShell).toBeDefined();
+});
+
+test("entitiesShell methods can be mocked individually", async () => {
+	const { entitiesShell } = await import("./entities.shell");
+
+	// Mock individual methods directly
+	entitiesShell.turboRunBuild = mock(
+		() =>
+			({
+				exitCode: 0,
+				json: () => Promise.resolve({ packages: ["test-package"] }),
+			}) as unknown as $.ShellPromise,
+	);
+
+	entitiesShell.runBiomeCheck = mock(
+		() =>
+			({
+				exitCode: 0,
+				text: () => "biome check completed",
+			}) as unknown as $.ShellPromise,
+	);
+
+	// Test that mocks work
+	const result = await entitiesShell.turboRunBuild(["--filter=test"]).json();
+	expect(result.packages).toEqual(["test-package"]);
+
+	const biomeResult = await entitiesShell.runBiomeCheck("test-file.ts");
+	expect(biomeResult.text()).toBe("biome check completed");
+});

package/src/entities/entities.shell.ts

@@ -0,0 +1,81 @@
+import { $ } from "bun";
+
+type EntitiesShell = {
+	touch: (filePath: string) => ReturnType<typeof $>;
+
+	gitStatus: () => ReturnType<typeof $>;
+
+	gitRevParse: (ref: string) => ReturnType<typeof $>;
+	gitFirstCommit: () => ReturnType<typeof $>;
+
+	gitLogHashes: (args: string[]) => ReturnType<typeof $>;
+
+	gitShow: (hash: string) => ReturnType<typeof $>;
+	gitShowNameOnly: (hash: string) => ReturnType<typeof $>;
+	gitShowPackageJsonAtTag: (tag: string, packagePath: string) => ReturnType<typeof $>;
+
+	gitDiff: (file: string) => ReturnType<typeof $>;
+	gitBranchShowCurrent: () => ReturnType<typeof $>;
+
+	gitTag: (tagName: string, message: string, options: { force?: string }) => ReturnType<typeof $>;
+	gitTagList: (prefix: string) => ReturnType<typeof $>;
+	gitTagLatest: (prefix: string) => ReturnType<typeof $>;
+	gitTagInfo: (tagName: string) => ReturnType<typeof $>;
+	gitTagExists: (tagName: string) => ReturnType<typeof $>;
+	gitPushTag: (tagName: string) => ReturnType<typeof $>;
+	gitDeleteTag: (tagName: string) => ReturnType<typeof $>;
+
+	gitMergeBaseIsAncestor: (ancestor: string, descendant: string) => ReturnType<typeof $>;
+
+	gitCheckout: (tagName: string) => ReturnType<typeof $>;
+
+	turboRunBuild: (args: string[]) => ReturnType<typeof $>;
+
+	runBiomeCheck: (filePath: string) => ReturnType<typeof $>;
+};
+
+export const entitiesShell: EntitiesShell = {
+	touch: (filePath: string) => $`touch ${filePath}`.quiet().nothrow(),
+
+	gitStatus: () => $`git status --porcelain`.quiet().nothrow(),
+
+	gitRevParse: (ref: string) => $`git rev-parse ${ref}`.quiet().nothrow(),
+	gitFirstCommit: () => $`git rev-list --max-parents=0 HEAD`.nothrow().quiet(),
+
+	gitLogHashes: (args: string[]) =>
+		$`git log --pretty=format:"%H" ${args.join(" ")}`.quiet().nothrow(),
+
+	gitShow: (hash: string) =>
+		$`git show --format="%H%n%an%n%ad%n%s%n%B" --no-patch ${hash}`.quiet().nothrow(),
+	gitShowNameOnly: (hash: string) => $`git show --name-only --format="" ${hash}`.quiet().nothrow(),
+	gitShowPackageJsonAtTag: (tag: string, packagePath: string) =>
+		$`git show ${tag}:${packagePath}`.quiet().nothrow(),
+
+	gitDiff: (file: string) => $`git diff --cached -- ${file}`.quiet().nothrow(),
+	gitBranchShowCurrent: () => $`git branch --show-current`.quiet().nothrow(),
+
+	gitTag: (tagName: string, message: string, options: { force?: string }) =>
+		$`git tag ${options.force} -a ${tagName} -m "${message}"`.quiet().nothrow(),
+	gitTagList: (prefix: string) =>
+		$`git tag --list "${prefix}*" --sort=-version:refname`.quiet().nothrow(),
+	gitTagLatest: (prefix: string) =>
+		$`git tag --sort=-version:refname --list "${prefix}*" | head -1`.nothrow().quiet(),
+	gitTagInfo: (tagName: string) =>
+		$`git tag -l --format='%(creatordate:iso8601)%0a%(contents:subject)' ${tagName}`
+			.quiet()
+			.nothrow(),
+	gitTagExists: (tagName: string) => $`git tag --list ${tagName}`.quiet().nothrow(),
+	gitPushTag: (tagName: string) => $`git push origin ${tagName}`.quiet().nothrow(),
+	gitDeleteTag: (tagName: string) => $`git tag -d ${tagName}`.quiet().nothrow(),
+
+	gitMergeBaseIsAncestor: (ancestor: string, descendant: string) =>
+		$`git merge-base --is-ancestor ${ancestor} ${descendant}`.quiet().nothrow(),
+
+	gitCheckout: (tagName: string) => $`git checkout ${tagName}`.quiet().nothrow(),
+
+	turboRunBuild: (args: string[]) =>
+		$`bunx turbo run build ${args.join(" ")} --dry-run=json`.nothrow(),
+
+	runBiomeCheck: (filePath: string) =>
+		$`bun biome check --write --no-errors-on-unmatched ${filePath}`.quiet().nothrow(),
+};

package/src/entities/index.ts

@@ -0,0 +1,11 @@
+export * from "./affected";
+export * from "./branch";
+export * from "./commit";
+export * from "./compose";
+export * from "./intershell-config/intershell-config.default";
+export * from "./package";
+export * from "./package-changelog";
+export * from "./package-commits";
+export * from "./package-tags";
+export * from "./package-version";
+export * from "./tag";

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

@@ -0,0 +1,229 @@
+import type { IConfig } from "./intershell-config.types";
+
+export * from "./intershell-config.types";
+
+export const defaultConfig = {
+	commit: {
+		conventional: {
+			type: {
+				list: [
+					{
+						type: "feat",
+						label: "Features",
+						description: "A new feature",
+						category: "features" as const,
+						emoji: "🚀",
+						badgeColor: "00D4AA",
+						breakingAllowed: true,
+					},
+					{
+						type: "fix",
+						label: "Bug Fixes",
+						description: "A bug fix",
+						category: "bugfixes" as const,
+						emoji: "🐛",
+						badgeColor: "EF4444",
+						breakingAllowed: true,
+					},
+					{
+						type: "docs",
+						label: "Documentation",
+						description: "Documentation only changes",
+						category: "documentation" as const,
+						emoji: "📚",
+						badgeColor: "646CFF",
+						breakingAllowed: false,
+					},
+					{
+						type: "style",
+						label: "Style",
+						description: "Changes that do not affect the meaning of the code",
+						category: "refactoring" as const,
+						emoji: "🎨",
+						badgeColor: "8B5CF6",
+						breakingAllowed: false,
+					},
+					{
+						type: "refactor",
+						label: "Refactoring",
+						description: "A code change that neither fixes a bug nor adds a feature",
+						category: "refactoring" as const,
+						emoji: "🔧",
+						badgeColor: "007ACC",
+						breakingAllowed: true,
+					},
+					{
+						type: "perf",
+						label: "Performance",
+						description: "A code change that improves performance",
+						category: "refactoring" as const,
+						emoji: "⚡",
+						badgeColor: "60a5fa",
+						breakingAllowed: true,
+					},
+					{
+						type: "test",
+						label: "Testing",
+						description: "Adding missing tests or correcting existing tests",
+						category: "infrastructure" as const,
+						emoji: "🧪",
+						badgeColor: "10B981",
+						breakingAllowed: false,
+					},
+					{
+						type: "ci",
+						label: "CI/CD",
+						description: "Changes to CI configuration files and scripts",
+						category: "infrastructure" as const,
+						emoji: "👷",
+						badgeColor: "2496ED",
+						breakingAllowed: false,
+					},
+					{
+						type: "chore",
+						label: "Chores",
+						description: "Other changes that don't modify src or test files",
+						category: "other" as const,
+						emoji: "🔨",
+						badgeColor: "495057",
+						breakingAllowed: false,
+					},
+					{
+						type: "revert",
+						label: "Revert",
+						description: "Reverts a previous commit",
+						category: "other" as const,
+						emoji: "⏪",
+						badgeColor: "DC2626",
+						breakingAllowed: true,
+					},
+					{
+						type: "merge",
+						label: "Merge",
+						description: "Merge commits (pull requests, branches)",
+						category: "other" as const,
+						emoji: "🔀",
+						badgeColor: "6B7280",
+						breakingAllowed: false,
+					},
+					{
+						type: "deps",
+						label: "Dependencies",
+						description: "Dependency updates and changes",
+						category: "dependencies" as const,
+						emoji: "📦",
+						badgeColor: "059669",
+						breakingAllowed: true,
+					},
+					{
+						type: "other",
+						label: "Other",
+						description: "Other types of changes",
+						category: "other" as const,
+						emoji: "⚠️",
+						badgeColor: "6B7280",
+						breakingAllowed: false,
+					},
+					{
+						type: "release",
+						label: "Release",
+						description: "Release version changes",
+						category: "other" as const,
+						emoji: "🚀",
+						badgeColor: "059669",
+						breakingAllowed: false,
+					},
+				] as const,
+			},
+			scopes: {
+				list: [],
+			},
+			description: {
+				minLength: 3,
+				maxLength: 72,
+				shouldNotEndWithPeriod: true,
+				shouldNotStartWithType: true,
+			},
+			bodyLines: {
+				minLength: 3,
+				maxLength: 120,
+			},
+		},
+		staged: [
+			{
+				filePattern: [
+					/\.vscode\/.*/,
+					/coverage\/.*/,
+					/dist\/.*/,
+					/node_modules\/.*/,
+					/\.env/,
+					/\.act/,
+				],
+				description: "development files should not be manually committed",
+			},
+			{
+				filePattern: [/CHANGELOG.md/],
+				disabled: process.env.CI === "true",
+				description:
+					"CHANGELOG.md should be auto-generated by 'bun run version:prepare' and 'bun run version:apply'",
+			},
+			{
+				filePattern: [/package.json/],
+				contentPattern: [
+					/^[+-].*"version":\s*"[^"]+"/m, // Manual version changes
+				],
+				ignore: { mode: "create" },
+				disabled: process.env.CI === "true",
+				description:
+					"package.json version should be auto-generated by 'bun run version:prepare' and 'bun run version:apply'",
+			},
+		],
+	},
+	package: {
+		selectiveVersioning: {
+			enabled: true,
+			description: "Enforce selective versioning based on private field",
+		},
+		semanticVersioning: {
+			enabled: true,
+			description: "Ensure versions follow semantic versioning format",
+		},
+		description: {
+			enabled: true,
+			description: "Require descriptions for versioned packages",
+		},
+	},
+	branch: {
+		defaultBranch: "main",
+		name: {
+			minLength: 1,
+			maxLength: 100,
+			allowedCharacters: /^[a-zA-Z0-9\-_/.]+$/,
+			noConsecutiveSeparators: true,
+			noLeadingTrailingSeparators: true,
+		},
+		prefixes: [
+			"feature",
+			"fix",
+			"hotfix",
+			"release",
+			"docs",
+			"refactor",
+			"ci",
+			"chore",
+			"wip",
+			"renovate",
+		],
+	},
+	tag: {
+		name: {
+			enabled: true,
+			description: "Validate tag name structure and content",
+			minLength: 1,
+			maxLength: 100,
+			allowedCharacters: /^[a-zA-Z0-9\-_.]+$/,
+			noSpaces: true,
+			noSpecialChars: false,
+		},
+	},
+} as const satisfies IConfig;