intershell 0.3.0

package/src/entities/package-commits/dependency-analyzer.ts

@@ -0,0 +1,194 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { entitiesShell } from "../entities.shell";
+import { EntityPackage, type TsConfig, type TsConfigPaths } from "../package";
+
+export class EntityDependencyAnalyzer {
+	private readonly package: EntityPackage;
+
+	constructor(packageInstance: EntityPackage) {
+		this.package = packageInstance;
+	}
+
+	/**
+	 * Get internal monorepo dependencies for a package at a specific tag/commit
+	 * Returns only dependencies within this monorepo
+	 */
+	async getPackageDependenciesAtRef(reference: string): Promise<string[]> {
+		try {
+			// Get all internal packages in the monorepo
+			const allPackages = await EntityPackage.getAllPackages();
+
+			// Get package.json dependencies
+			const packageJsonDeps = await this.getPackageJsonDependencies(reference);
+
+			// Get tsconfig dependencies
+			const tsconfigDeps = await this.getTsConfigDependencies(reference);
+
+			// Combine and filter for internal dependencies only
+			const allDeps = [...new Set([...packageJsonDeps, ...tsconfigDeps])];
+
+			return allDeps.filter((dep) => allPackages.includes(dep));
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * Get package.json dependencies for a package at a specific reference
+	 */
+	private async getPackageJsonDependencies(reference: string): Promise<string[]> {
+		try {
+			const result = await entitiesShell.gitShowPackageJsonAtTag(
+				reference,
+				this.package.getJsonPath(),
+			);
+
+			if (result.exitCode !== 0) {
+				return [];
+			}
+
+			const packageJson = JSON.parse(result.text()) as Record<string, unknown>;
+			const deps = [
+				...(packageJson.dependencies
+					? Object.keys(packageJson.dependencies as Record<string, string>)
+					: []),
+				...(packageJson.devDependencies
+					? Object.keys(packageJson.devDependencies as Record<string, string>)
+					: []),
+				...(packageJson.peerDependencies
+					? Object.keys(packageJson.peerDependencies as Record<string, string>)
+					: []),
+			];
+
+			// Filter for @repo/ packages and return without @repo/ prefix
+			return deps.filter((dep) => dep.startsWith("@repo/")).map((dep) => dep.replace("@repo/", ""));
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * Get tsconfig dependencies by resolving paths to actual internal packages
+	 */
+	private async getTsConfigDependencies(reference: string): Promise<string[]> {
+		try {
+			const packagePath = this.package.getPath();
+			const tsconfigPaths = await this.getTsConfigPaths(reference);
+
+			const deps: string[] = [];
+
+			for (const [alias, paths] of Object.entries(tsconfigPaths)) {
+				// Check if alias itself is an internal package
+				if (alias.startsWith("@repo/")) {
+					deps.push(alias.replace("@repo/", ""));
+				}
+
+				// Check if paths point to internal packages
+				if (Array.isArray(paths)) {
+					for (const path of paths) {
+						const resolvedPath = resolve(packagePath, path);
+						const internalPackage = this.findInternalPackageFromPath(resolvedPath);
+						if (internalPackage) {
+							deps.push(internalPackage);
+						}
+					}
+				}
+			}
+
+			return [...new Set(deps)];
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * Find internal package name from absolute path
+	 */
+	private findInternalPackageFromPath(absolutePath: string): string | null {
+		// Check if path points to packages/ or apps/ directory
+		const packagesMatch = absolutePath.match(/\/packages\/([^/]+)/);
+		const appsMatch = absolutePath.match(/\/apps\/([^/]+)/);
+
+		if (packagesMatch) {
+			return `@repo/${packagesMatch[1]}`;
+		}
+
+		if (appsMatch) {
+			return appsMatch[1];
+		}
+
+		return null;
+	}
+
+	/**
+	 * Get TypeScript configuration paths for a package at a specific git reference
+	 */
+	private async getTsConfigPaths(reference: string): Promise<TsConfigPaths> {
+		try {
+			const tsconfig = await this.readTsconfigAtRef(reference);
+			const resolvedConfig = await this.resolveExtendedTsConfig(tsconfig, this.package.getPath());
+
+			return resolvedConfig.compilerOptions?.paths || {};
+		} catch {
+			return {};
+		}
+	}
+
+	/**
+	 * Read tsconfig.json at a specific git reference
+	 */
+	private async readTsconfigAtRef(reference: string): Promise<TsConfig> {
+		try {
+			const result = await entitiesShell.gitShow(`${reference}:${this.package.getTsconfigPath()}`);
+			if (result.exitCode !== 0) {
+				// If tsconfig.json doesn't exist at this reference, return empty config
+				return {};
+			}
+
+			const content = result.text();
+			return JSON.parse(content);
+		} catch {
+			// If parsing fails, return empty config
+			return {};
+		}
+	}
+
+	/**
+	 * Resolve extended TypeScript configurations
+	 */
+	private async resolveExtendedTsConfig(config: TsConfig, packagePath: string): Promise<TsConfig> {
+		if (!config.extends) {
+			return config;
+		}
+
+		const extendedPath = resolve(packagePath, config.extends);
+		if (!existsSync(extendedPath)) {
+			return config;
+		}
+
+		try {
+			const extendedContent = readFileSync(extendedPath, "utf-8");
+			const extendedConfig: TsConfig = JSON.parse(extendedContent);
+
+			// Recursively resolve extended configs
+			const resolvedExtended = await this.resolveExtendedTsConfig(extendedConfig, packagePath);
+
+			// Merge configurations
+			return {
+				...resolvedExtended,
+				...config,
+				compilerOptions: {
+					...resolvedExtended.compilerOptions,
+					...config.compilerOptions,
+					paths: {
+						...(resolvedExtended.compilerOptions?.paths || {}),
+						...(config.compilerOptions?.paths || {}),
+					},
+				},
+			};
+		} catch {
+			return config;
+		}
+	}
+}

package/src/entities/package-commits/index.ts

@@ -0,0 +1,2 @@
+export * from "./dependency-analyzer";
+export * from "./package-commits";

package/src/entities/package-commits/package-commits.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { EntityPackage } from "../package";
+import { EntityPackageCommits } from "./package-commits";
+
+describe("EntityPackageCommits", () => {
+	test("should create instance", () => {
+		const packageInstance = new EntityPackage("api");
+		const commitPackage = new EntityPackageCommits(packageInstance);
+		expect(commitPackage).toBeDefined();
+	});
+
+	test("should create root instance", () => {
+		const packageInstance = new EntityPackage("root");
+		const rootCommitPackage = new EntityPackageCommits(packageInstance);
+		expect(rootCommitPackage).toBeDefined();
+	});
+
+	test("should have main method", () => {
+		const packageInstance = new EntityPackage("api");
+		const commitPackage = new EntityPackageCommits(packageInstance);
+		// Check that the main method exists
+		expect(typeof commitPackage.getCommitsInRange).toBe("function");
+	});
+
+	describe("getCommitsInRange", () => {
+		test("should return empty array when git operations fail", async () => {
+			const packageInstance = new EntityPackage("root");
+			const commitPackage = new EntityPackageCommits(packageInstance);
+			// Test with invalid range to trigger error handling
+			const result = await commitPackage.getCommitsInRange("invalid", "invalid");
+			expect(Array.isArray(result)).toBe(true);
+			expect(result.length).toBe(0);
+		});
+
+		test("should handle package-specific commits", async () => {
+			const packageInstance = new EntityPackage("api");
+			const commitPackage = new EntityPackageCommits(packageInstance);
+			// Test with invalid range to trigger error handling
+			const result = await commitPackage.getCommitsInRange("invalid", "invalid");
+			expect(Array.isArray(result)).toBe(true);
+			expect(result.length).toBe(0);
+		});
+	});
+});

package/src/entities/package-commits/package-commits.ts

@@ -0,0 +1,191 @@
+import type { ParsedCommitData } from "../commit";
+import { EntityCommit } from "../commit";
+import { entitiesShell } from "../entities.shell";
+import { EntityPackage } from "../package";
+import { EntityDependencyAnalyzer } from "./dependency-analyzer";
+
+export class EntityPackageCommits {
+	private package: EntityPackage;
+	private commit: EntityCommit;
+	private dependencyAnalyzer: EntityDependencyAnalyzer;
+
+	constructor(packageInstance: EntityPackage) {
+		this.package = packageInstance;
+		this.commit = new EntityCommit();
+		this.dependencyAnalyzer = new EntityDependencyAnalyzer(this.package);
+	}
+
+	/**
+	 * Get the first commit for this package
+	 */
+	async getFirstCommitForPackage(): Promise<string> {
+		if (this.package.getName() === "root") {
+			// For root package, use the very first commit of the repository
+			const result = await entitiesShell.gitFirstCommit();
+			if (result.exitCode !== 0) {
+				throw new Error("Could not find first commit");
+			}
+			return result.text().trim();
+		}
+
+		// For sub-packages, find the first commit where the package directory was introduced
+		const packagePath = this.package.getPath();
+		const result = await entitiesShell.gitLogHashes([packagePath]);
+
+		if (result.exitCode !== 0 || !result.text().trim()) {
+			// If no commits found for this package path, fall back to first commit
+			const firstCommitResult = await entitiesShell.gitFirstCommit();
+			if (firstCommitResult.exitCode !== 0) {
+				throw new Error("Could not find first commit");
+			}
+			return firstCommitResult.text().trim();
+		}
+
+		// Get the last commit hash from the result (since git log returns newest first)
+		const commitHashes = result.text().trim().split("\n").filter(Boolean);
+		if (commitHashes.length === 0) {
+			const firstCommitResult = await entitiesShell.gitFirstCommit();
+			if (firstCommitResult.exitCode !== 0) {
+				throw new Error("Could not find first commit");
+			}
+			return firstCommitResult.text().trim();
+		}
+
+		// Return the last commit (which is the first chronologically)
+		return commitHashes[commitHashes.length - 1];
+	}
+
+	/**
+	 * Get commits in a range for this package with dependency filtering
+	 */
+	async getCommitsInRange(from: string, to: string): Promise<ParsedCommitData[]> {
+		const gitRange = from === "0.0.0" ? to : `${from}..${to}`;
+
+		try {
+			// Get all commit hashes (both regular and merge commits)
+			const [allHashesResult, mergeHashesResult] = await Promise.all([
+				entitiesShell.gitLogHashes([gitRange]),
+				entitiesShell.gitLogHashes([gitRange, "--merges"]),
+			]);
+
+			const allHashes =
+				allHashesResult.exitCode === 0
+					? allHashesResult.text().trim().split("\n").filter(Boolean)
+					: [];
+			const mergeHashes =
+				mergeHashesResult.exitCode === 0
+					? mergeHashesResult.text().trim().split("\n").filter(Boolean)
+					: [];
+
+			// For non-root packages, filter merge commits by package path
+			const commitHashes = await this.filterMergeCommitsByPackage(allHashes, mergeHashes);
+
+			// Parse all commits
+			const allCommits = await Promise.all(
+				commitHashes.map((hash) => this.commit.parseByHash(hash)),
+			);
+
+			// Filter commits based on package dependencies at each commit
+			const relevantCommits: ParsedCommitData[] = [];
+			for (const commit of allCommits) {
+				// Check if commit affects this package or its dependencies
+				const affected = await this.getCommitAffectedPackages(commit);
+
+				// Include commit if it affects this package directly or any of its dependencies
+				if (affected.direct !== null || affected.dependencies.length > 0) {
+					relevantCommits.push(commit);
+				}
+			}
+
+			// Sort commits: merge commits first, then orphan commits, both by date
+			return this.sortCommits(relevantCommits);
+		} catch (error) {
+			console.warn("Failed to get commits in range:", error);
+			return [];
+		}
+	}
+
+	/**
+	 * Get which packages are affected by a commit (direct and dependencies)
+	 * Analyzes the commit's file changes against package dependencies
+	 */
+	async getCommitAffectedPackages(commit: ParsedCommitData): Promise<{
+		direct: string | null;
+		dependencies: string[];
+	}> {
+		if (!commit.files?.length) {
+			return { direct: null, dependencies: [] };
+		}
+
+		// Get package dependencies at the commit
+		const commitHash = commit.info?.hash || "HEAD";
+		const packageDeps = await this.dependencyAnalyzer.getPackageDependenciesAtRef(commitHash);
+
+		// Check if commit affects this package directly
+		const packagePath = this.package.getPath();
+		const affectsDirect = this.package.isRoot()
+			? commit.files.length > 0 // For root package, any file change affects it
+			: commit.files.some((file) => file.startsWith(packagePath));
+
+		// Check if commit affects any dependencies
+		const affectedDependencies: string[] = [];
+		for (const dep of packageDeps) {
+			const depPackage = new EntityPackage(dep);
+			const depPath = depPackage.getPath();
+			if (commit.files.some((file) => file.startsWith(depPath))) {
+				affectedDependencies.push(dep);
+			}
+		}
+
+		return {
+			direct: affectsDirect ? this.package.getName() : null,
+			dependencies: affectedDependencies,
+		};
+	}
+
+	/**
+	 * Deduplicate merge commits - remove hashes that are already included in merge commits
+	 */
+	private async filterMergeCommitsByPackage(
+		allHashes: string[],
+		mergeHashes: string[],
+	): Promise<string[]> {
+		// For each merge commit, get the individual commits inside it
+		const individualCommits = new Set<string>();
+
+		for (const mergeHash of mergeHashes) {
+			const prCommitsResult = await entitiesShell.gitLogHashes([`${mergeHash}^..${mergeHash}^2`]);
+			if (prCommitsResult.exitCode === 0) {
+				const prHashes = prCommitsResult.text().trim().split("\n").filter(Boolean);
+				prHashes.forEach((hash) => {
+					individualCommits.add(hash);
+				});
+			}
+		}
+
+		// Remove individual commits that are already included in merge commits
+		const filteredHashes = allHashes.filter((hash) => !individualCommits.has(hash));
+
+		// Return merge commits + filtered individual commits
+		return [...new Set([...filteredHashes, ...mergeHashes])];
+	}
+
+	/**
+	 * Sort commits: merge commits first, then orphan commits, both by date (newest first)
+	 */
+	private sortCommits(commits: ParsedCommitData[]): ParsedCommitData[] {
+		const mergeCommits = commits.filter((commit) => commit.message.isMerge);
+		const orphanCommits = commits.filter(
+			(commit) =>
+				!commit.message.isMerge &&
+				!mergeCommits.some((mergeCommit) =>
+					mergeCommit.pr?.prCommits?.some((prCommit) => prCommit.info?.hash === commit.info?.hash),
+				),
+		);
+
+		const sortByDate = (a: ParsedCommitData, b: ParsedCommitData) =>
+			new Date(b.info?.date || "0").getTime() - new Date(a.info?.date || "0").getTime();
+
+		return [...mergeCommits.sort(sortByDate), ...orphanCommits.sort(sortByDate)];
+	}
+}

package/src/entities/package-tags/index.ts

@@ -0,0 +1 @@
+export { EntityPackageTags } from "./package-tags";

package/src/entities/package-tags/package-tags.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import { EntityPackage } from "../package";
+import { EntityPackageTags } from "./package-tags";
+
+describe("EntityPackageTags", () => {
+	test("should create instance", () => {
+		const packageInstance = new EntityPackage("api");
+		const tagPackage = new EntityPackageTags(packageInstance);
+		expect(tagPackage).toBeDefined();
+	});
+
+	test("should create root instance", () => {
+		const packageInstance = new EntityPackage("root");
+		const tagPackage = new EntityPackageTags(packageInstance);
+		expect(tagPackage).toBeDefined();
+	});
+
+	test("should detect tag prefix for root package", () => {
+		const packageInstance = new EntityPackage("root");
+		const tagPackage = new EntityPackageTags(packageInstance);
+
+		expect(tagPackage.detectTagPrefix("v1.0.0")).toBe("v");
+		expect(tagPackage.detectTagPrefix("v2.1.3")).toBe("v");
+		expect(tagPackage.detectTagPrefix("v0.0.1")).toBe("v");
+	});
+
+	test("should detect tag prefix for package-specific tags", () => {
+		const packageInstance = new EntityPackage("api");
+		const tagPackage = new EntityPackageTags(packageInstance);
+
+		expect(tagPackage.detectTagPrefix("api-v1.0.0")).toBe("api-v");
+		expect(tagPackage.detectTagPrefix("intershell-v2.1.3")).toBe("intershell-v");
+		expect(tagPackage.detectTagPrefix("ui-v0.0.1")).toBe("ui-v");
+	});
+
+	test("should return undefined for invalid tag formats", () => {
+		const packageInstance = new EntityPackage("api");
+		const tagPackage = new EntityPackageTags(packageInstance);
+
+		expect(tagPackage.detectTagPrefix("1.0.0")).toBeUndefined();
+		expect(tagPackage.detectTagPrefix("invalid")).toBeUndefined();
+		expect(tagPackage.detectTagPrefix("")).toBeUndefined();
+	});
+
+	test("should compare versions correctly", () => {
+		const packageInstance = new EntityPackage("api");
+		const tagPackage = new EntityPackageTags(packageInstance);
+
+		expect(tagPackage.compareVersions("1.0.0", "1.0.1")).toBe(-1);
+		expect(tagPackage.compareVersions("1.0.1", "1.0.0")).toBe(1);
+		expect(tagPackage.compareVersions("1.0.0", "1.0.0")).toBe(0);
+		expect(tagPackage.compareVersions("2.0.0", "1.9.9")).toBe(1);
+		expect(tagPackage.compareVersions("1.0.0", "2.0.0")).toBe(-1);
+	});
+
+	test("should handle version comparison with different lengths", () => {
+		const packageInstance = new EntityPackage("api");
+		const tagPackage = new EntityPackageTags(packageInstance);
+
+		expect(tagPackage.compareVersions("1.0", "1.0.0")).toBe(0);
+		expect(tagPackage.compareVersions("1.0.0", "1.0")).toBe(0);
+		expect(tagPackage.compareVersions("1", "1.0.0")).toBe(0);
+	});
+
+	test("should handle version comparison edge cases", () => {
+		const packageInstance = new EntityPackage("api");
+		const tagPackage = new EntityPackageTags(packageInstance);
+
+		expect(tagPackage.compareVersions("0.0.0", "0.0.1")).toBe(-1);
+		expect(tagPackage.compareVersions("0.1.0", "0.0.9")).toBe(1);
+		expect(tagPackage.compareVersions("1.0.0", "0.9.9")).toBe(1);
+	});
+});