intershell 0.3.0

package/src/entities/commit/pr.ts

@@ -0,0 +1,241 @@
+import { EntityBranch, type ParsedBranch } from "../branch";
+import { entitiesShell } from "../entities.shell";
+import type { IConfig, PRCategory } from "../intershell-config/intershell-config.types";
+import type { ParsedCommitData, PRStats } from "./commit.types";
+
+export class EntityPr {
+	private readonly defaultBranch: string | undefined;
+	constructor(readonly config: IConfig) {
+		this.defaultBranch = config?.branch?.defaultBranch;
+	}
+
+	async getPRInfo(
+		parseByHash: (hash: string) => Promise<ParsedCommitData>,
+		hash: string,
+		message: ParsedCommitData["message"],
+	): Promise<ParsedCommitData["pr"]> {
+		try {
+			const prNumber = extractPRNumber(message);
+
+			if (!prNumber) {
+				return undefined;
+			}
+
+			const prCommits = await getPRCommits(hash, parseByHash);
+
+			return {
+				prNumber: extractPRNumber(message) || "",
+				prCategory: categorizePR(prCommits, message),
+				prStats: getPRStats(prCommits),
+				prCommits: prCommits.length > 0 ? prCommits : [],
+				prBranchName: this.getPrBranch({ message }),
+			};
+		} catch (error) {
+			console.warn(`Failed to get PR info for commit ${hash}: ${error}`);
+			return undefined;
+		}
+	}
+
+	public getPrBranch({ message }: ParsedCommitData): ParsedBranch {
+		if (!message.isMerge) {
+			return {
+				name: this.defaultBranch || "",
+				fullName: this.defaultBranch || "",
+			};
+		}
+
+		const mainMessage = message.bodyLines?.join("\n") || "";
+		if (!mainMessage.includes("from ")) {
+			return {
+				name: this.defaultBranch || "",
+				fullName: this.defaultBranch || "",
+			};
+		}
+
+		const fromIndex = mainMessage.indexOf("from ");
+		const afterFrom = mainMessage.substring(fromIndex + 5);
+		let firstLine = afterFrom.split("\n")[0].trim();
+		const originalFullName = firstLine; // Store the original full name
+
+		if (firstLine.includes(":")) {
+			firstLine = firstLine.split(":").reverse()[0];
+		}
+
+		// Use the centralized EntityBranch parsing logic
+		const branchInstance = new EntityBranch();
+		const parsed = branchInstance.parseByName(firstLine);
+
+		// Return the parsed branch with the original full name
+		return {
+			name: parsed.name,
+			fullName: originalFullName, // Keep the original full name from the commit
+		};
+	}
+}
+
+function extractPRNumber(mergeMessage: ParsedCommitData["message"]): string | undefined {
+	// Try different merge commit patterns
+	const patterns = [
+		/Merge pull request #(\d+)/, // "Merge pull request #123"
+		/Merge PR #(\d+)/, // "Merge PR #123"
+		/Merge.*#(\d+)/, // "Merge branch 'feature' into main #123"
+		/#(\d+)/, // Any message containing #123 (secure pattern)
+	];
+
+	for (const pattern of patterns) {
+		const match = mergeMessage.description.match(pattern);
+		if (match) {
+			return match[1];
+		}
+	}
+
+	return undefined;
+}
+
+async function getPRCommits(
+	mergeCommitHash: string,
+	parseByHash: (hash: string) => Promise<ParsedCommitData>,
+): Promise<ParsedCommitData[]> {
+	try {
+		// First, try the regular merge approach
+		const result = await entitiesShell.gitLogHashes([`${mergeCommitHash}^..${mergeCommitHash}^2`]);
+
+		if (result.exitCode === 0) {
+			const commitHashes = result.text().trim().split("\n").filter(Boolean);
+
+			// If we found multiple commits, this is a regular merge
+			if (commitHashes.length > 1) {
+				const prCommits = await Promise.all(
+					commitHashes.map(async (hash) => {
+						try {
+							return await parseByHash(hash);
+						} catch (error) {
+							console.warn(`Failed to parse PR commit ${hash}: ${error}`);
+							// Fallback to basic info if parsing fails
+							return {
+								message: {
+									type: "other",
+									description: "Failed to parse commit",
+									isMerge: false,
+									isDependency: false,
+									isBreaking: false,
+								},
+								info: {
+									hash: hash.trim(),
+								},
+							} as ParsedCommitData;
+						}
+					}),
+				);
+
+				const validCommits = prCommits.filter(
+					(commit) => commit.info?.hash && commit.message.description,
+				);
+				return validCommits;
+			}
+
+			// If we only found 1 commit, this might be a squash merge
+			// For squash merges, we can't recover individual commits from git history
+			// But we can create a synthetic commit representing the squashed changes
+			if (commitHashes.length === 1) {
+				const squashedHash = commitHashes[0];
+				try {
+					const squashedCommit = await parseByHash(squashedHash);
+					// Mark this as a squashed commit so the changelog can handle it appropriately
+					return [
+						{
+							...squashedCommit,
+							message: {
+								...squashedCommit.message,
+								description: `Squashed changes from PR (${squashedCommit.message.description})`,
+							},
+						},
+					];
+				} catch (error) {
+					console.warn(`Failed to parse squashed commit ${squashedHash}: ${error}`);
+					return [];
+				}
+			}
+		}
+
+		// Fallback: return empty array if no commits found
+		return [];
+	} catch (_error) {
+		return [];
+	}
+}
+
+function categorizePR(
+	prCommits: ParsedCommitData[],
+	mergeMessage: ParsedCommitData["message"],
+): PRCategory {
+	if (
+		mergeMessage.description.includes("renovate") ||
+		mergeMessage.description.includes("dependabot") ||
+		mergeMessage.bodyLines.some((line) => line.toLowerCase().includes("dependency"))
+	) {
+		return "dependencies";
+	}
+
+	const scores = {
+		features: 0,
+		bugfixes: 0,
+		dependencies: 0,
+		infrastructure: 0,
+		documentation: 0,
+		refactoring: 0,
+	};
+
+	for (const commit of prCommits) {
+		const commitType = commit.message.type;
+
+		switch (commitType) {
+			case "feat":
+				scores.features += 3;
+				break;
+			case "fix":
+				scores.bugfixes += 2;
+				break;
+			case "deps":
+			case "chore":
+				if (
+					commit.message.description.includes("dep") ||
+					commit.message.description.includes("update") ||
+					commit.message.description.includes("upgrade")
+				) {
+					scores.dependencies += 5;
+				} else if (
+					commit.message.description.includes("ci") ||
+					commit.message.description.includes("build") ||
+					commit.message.description.includes("workflow")
+				) {
+					scores.infrastructure += 2;
+				}
+				break;
+			case "docs":
+				scores.documentation += 2;
+				break;
+			case "refactor":
+			case "style":
+			case "perf":
+				scores.refactoring += 2;
+				break;
+			case "ci":
+			case "build":
+				scores.infrastructure += 3;
+				break;
+		}
+	}
+
+	const maxScore = Math.max(...Object.values(scores));
+	if (maxScore === 0) return "other";
+
+	const winner = Object.entries(scores).find(([_, score]) => score === maxScore);
+	return winner ? (winner[0] as PRCategory) : "other";
+}
+
+function getPRStats(prCommits: ParsedCommitData[]): PRStats {
+	return {
+		commitCount: prCommits.length,
+	};
+}