intershell 0.3.0

package/src/entities/commit/commit.ts

@@ -0,0 +1,245 @@
+import { entitiesShell } from "../entities.shell";
+import { entitiesConfig } from "../intershell-config/intershell-config";
+import type { IConfig } from "../intershell-config/intershell-config.types";
+import type { CommitMessageData, ParsedCommitData } from "./commit.types";
+import { EntityPr } from "./pr";
+
+const conventionalCommitRegex = /^([a-z]+)(\([a-zA-Z0-9@\-,\s/]+\))?(!)?:\s(.+)/;
+const depScopes = ["deps", "dependencies", "dep", "renovate", "dependabot"];
+const getIsMerge = (message: string) =>
+	message.startsWith("Merge pull request") || message.startsWith("Merge branch");
+const getIsDependency = (message: string) =>
+	message.includes("renovate[bot]") || message.includes("dependabot[bot]");
+
+export class EntityCommit {
+	private readonly config: IConfig;
+
+	constructor(config?: IConfig) {
+		this.config = config || entitiesConfig.getConfig();
+	}
+
+	static parseByMessage(message: string): CommitMessageData {
+		const lines = message.split("\n");
+		const subject = lines[0];
+		const bodyLines = lines.length > 1 ? lines.slice(1).filter((line) => line.trim()) : [];
+
+		const match = subject.match(conventionalCommitRegex);
+		if (!match) {
+			const type = getIsMerge(message) ? "merge" : getIsDependency(message) ? "deps" : "other";
+
+			return {
+				subject,
+				type,
+				description: subject,
+				scopes: [],
+				bodyLines: bodyLines,
+				isBreaking: false,
+				isMerge: type === "merge",
+				isDependency: type === "deps",
+			};
+		}
+
+		const [, type, scope, breaking, description] = match || [];
+		const scopes = scope ? scope.replace(/[()]/g, "").split(",") : [];
+		const isBreaking = breaking === "!";
+		const isMerge = getIsMerge(message);
+		const isDependency = scopes.some((s) => depScopes.includes(s)) || getIsDependency(message);
+
+		return { subject, type, scopes, description, bodyLines, isMerge, isBreaking, isDependency };
+	}
+
+	validateCommitMessage(message: string): string[] {
+		if (!message.trim()) return ["commit message cannot be empty"];
+		const match = EntityCommit.parseByMessage(message);
+
+		const errors: string[] = [];
+		const commitConfig = this.config.commit;
+
+		if (match.isMerge) {
+			// Validate merge commit
+			if (commitConfig.conventional.isMerge?.validator) {
+				const validation = commitConfig.conventional.isMerge.validator({ message: match });
+				if (typeof validation === "string") errors.push(`isMerge: ${validation}`);
+			}
+		} else {
+			// Validate conventional commit
+			// Type validation
+			if (commitConfig.conventional.type?.list && commitConfig.conventional.type.list.length > 0) {
+				const validTypes = commitConfig.conventional.type.list.map((t) => t.type);
+				if (!validTypes.includes(match.type)) {
+					errors.push(`type: invalid type "${match.type}". valid types: ${validTypes.join(", ")}`);
+				}
+			}
+
+			// Scope validation
+			if (
+				commitConfig.conventional.scopes?.list &&
+				commitConfig.conventional.scopes.list.length > 0
+			) {
+				if (match.scopes && match.scopes.length > 0) {
+					const scopesList = commitConfig.conventional.scopes.list;
+					const invalidScopes = match.scopes.filter((scope) => !scopesList.includes(scope));
+					if (invalidScopes.length > 0) {
+						errors.push(
+							`scopes: invalid scope(s) "${invalidScopes.join(", ")}". valid scopes: ${scopesList.join(", ")}`,
+						);
+					}
+				}
+			}
+
+			// Description validation
+			if (commitConfig.conventional.description) {
+				const desc = match.description;
+				const minLength = commitConfig.conventional.description.minLength;
+				if (minLength !== undefined && desc.length < minLength) {
+					errors.push(`description: should be at least ${minLength} characters long`);
+				}
+
+				const maxLength = commitConfig.conventional.description.maxLength;
+				if (maxLength !== undefined && desc.length > maxLength) {
+					errors.push(`description: should be max ${maxLength} chars, received: ${desc.length}`);
+				}
+
+				if (commitConfig.conventional.description.shouldNotEndWithPeriod && desc.endsWith(".")) {
+					errors.push("description: should not end with a period");
+				}
+
+				if (
+					commitConfig.conventional.description.shouldNotStartWithType &&
+					commitConfig.conventional.type?.list
+				) {
+					const firstWord = desc.split(" ")[0].toLowerCase();
+					const validTypes = commitConfig.conventional.type.list.map((t) => t.type);
+					if (validTypes.includes(firstWord)) {
+						errors.push(
+							`description: should not start with a type "${firstWord}". You're either duplicating the type or should use a different type.`,
+						);
+					}
+				}
+			}
+
+			// Body lines validation
+			if (commitConfig.conventional.bodyLines && match.bodyLines.length > 0) {
+				const minLength = commitConfig.conventional.bodyLines.minLength;
+				if (minLength !== undefined && match.bodyLines.every((line) => line.length < minLength)) {
+					errors.push(`bodyLines: should be ${minLength} characters or more`);
+				}
+
+				const maxLength = commitConfig.conventional.bodyLines.maxLength;
+				if (maxLength !== undefined && match.bodyLines.every((line) => line.length > maxLength)) {
+					errors.push(`bodyLines: should be ${maxLength} characters or less`);
+				}
+			}
+
+			// Breaking change validation
+			if (match.isBreaking && commitConfig.conventional.type?.list) {
+				const breakingAllowedTypes = commitConfig.conventional.type.list
+					.filter((t) => t.breakingAllowed)
+					.map((t) => t.type);
+				if (!breakingAllowedTypes.includes(match.type)) {
+					errors.push(
+						`isBreaking: breaking change is not allowed for this type, allowed types: ${breakingAllowedTypes.join(", ")}`,
+					);
+				}
+				if (match.description.length < 10) {
+					errors.push(
+						"isBreaking: breaking change description should be at least 10 characters long",
+					);
+				}
+			}
+		}
+
+		return errors;
+	}
+
+	formatCommitMessage(message: CommitMessageData): string {
+		let formatted = `${message.type}`;
+		if (message.scopes && message.scopes.length > 0) formatted += `(${message.scopes.join(", ")})`;
+		formatted += `: ${message.description}`;
+		if (message.bodyLines && message.bodyLines.length > 0)
+			formatted += `\n\n${message.bodyLines.join("\n")}`;
+		if (message.isBreaking) formatted += `\n\nBREAKING CHANGE: ${message.description}`;
+
+		return formatted;
+	}
+
+	async parseByHash(hash: string): Promise<ParsedCommitData> {
+		try {
+			const commitResult = await entitiesShell.gitShow(hash);
+			if (commitResult.exitCode !== 0)
+				throw new Error(
+					`Could not find commit ${hash}, exit code: ${commitResult.exitCode}, text: ${commitResult.text()}`,
+				);
+
+			const lines = commitResult.text().trim().split("\n");
+			const [commitHash, author, date, subject, ...bodyLines] = lines;
+			if (!subject) throw new Error(`No subject found for commit ${hash}`);
+
+			// Get files changed in this commit
+			const filesResult = await entitiesShell.gitShowNameOnly(hash);
+
+			const files =
+				filesResult.exitCode === 0 ? filesResult.text().trim().split("\n").filter(Boolean) : [];
+
+			const message = EntityCommit.parseByMessage(`${subject}\n${bodyLines.join("\n")}`);
+			const config = this.config || entitiesConfig.getConfig();
+			const parseByHash = this.parseByHash.bind(this);
+
+			return {
+				message,
+				info: {
+					hash: commitHash,
+					author: author || undefined,
+					date: date || undefined,
+				},
+				pr: message.isMerge
+					? await new EntityPr(config).getPRInfo(parseByHash, hash, message)
+					: undefined,
+				files,
+			};
+		} catch (error) {
+			throw new Error(
+				`Failed to parse commit ${hash}: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
+	async getStagedFiles(): Promise<{ stagedFiles: string[] }> {
+		const status = await entitiesShell.gitStatus().text();
+		const lines = status.split("\n").filter(Boolean);
+
+		return {
+			stagedFiles: lines
+				.filter((line) => line.startsWith("A ") || line.startsWith("M "))
+				.map((line) => line.substring(3)),
+		};
+	}
+
+	async validateStagedFiles(files: string[]): Promise<string[]> {
+		const errors: string[] = [];
+		const stagedConfig = this.config.commit.staged || [];
+
+		// Process each file individually for proper ignore logic and error reporting
+		for (const file of files) {
+			for (const pattern of stagedConfig) {
+				const fileNameMatches = pattern.filePattern.some((p) => p.test(file));
+				if (!fileNameMatches) continue;
+
+				const stagedDiff = await entitiesShell.gitDiff(file).text();
+				const contentMatches = pattern.contentPattern?.some((p) => p.test(stagedDiff)) ?? true;
+
+				// Check if this is a new file and should be ignored
+				const isNewFile =
+					stagedDiff.includes("new file mode") || stagedDiff.includes("--- /dev/null");
+				const shouldIgnore = pattern.ignore?.mode === "create" && isNewFile;
+				const isDisabled = pattern.disabled;
+
+				if (contentMatches && !shouldIgnore && !isDisabled) {
+					errors.push(`${file}: ${pattern.description}`);
+				}
+			}
+		}
+
+		return errors;
+	}
+}

package/src/entities/commit/commit.types.ts

@@ -0,0 +1,81 @@
+import type { ParsedBranch } from "../branch/branch.types";
+import type { PRCategory } from "../intershell-config/intershell-config.types";
+
+export type CommitMessageData =
+	| {
+			subject: string;
+			type: "other";
+			scopes?: string[];
+			description: string;
+			bodyLines: string[];
+			isBreaking: boolean;
+			isMerge: boolean;
+			isDependency: boolean;
+	  }
+	| {
+			subject: string;
+			type: string;
+			scopes?: string[];
+			description: string;
+			bodyLines: string[];
+			isBreaking: boolean;
+			isMerge: boolean;
+			isDependency: boolean;
+	  };
+
+export interface PRStats {
+	readonly commitCount: number;
+	readonly fileCount?: number;
+	readonly linesAdded?: number;
+	readonly linesDeleted?: number;
+}
+
+export type PRInfo = {
+	prNumber: string;
+	prCategory: PRCategory;
+	prStats: PRStats;
+	prCommits: ParsedCommitData[];
+	prBranchName: ParsedBranch;
+};
+
+export const prCategories: Record<PRCategory, { emoji: string; label: string }> = {
+	features: {
+		emoji: "🚀",
+		label: "Feature Releases",
+	},
+	infrastructure: {
+		emoji: "🛠️",
+		label: "Infrastructure & Tooling",
+	},
+	bugfixes: {
+		emoji: "🐛",
+		label: "Bug Fixes & Improvements",
+	},
+	refactoring: {
+		emoji: "🔄",
+		label: "Code Quality & Refactoring",
+	},
+	documentation: {
+		emoji: "📚",
+		label: "Documentation",
+	},
+	dependencies: {
+		emoji: "📦",
+		label: "Dependency Updates",
+	},
+	other: {
+		emoji: "🔄",
+		label: "Other Changes",
+	},
+};
+
+export interface ParsedCommitData {
+	message: CommitMessageData;
+	info?: {
+		hash: string;
+		author?: string;
+		date?: string;
+	};
+	pr?: PRInfo;
+	files?: string[];
+}

package/src/entities/commit/index.ts

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