intershell 0.3.0

package/src/entities/package/package.ts

@@ -0,0 +1,267 @@
+import { entitiesShell } from "../entities.shell";
+import { entitiesConfig } from "../intershell-config/intershell-config";
+import { packagesShell } from "./package.shell";
+import type { PackageJson, TsConfig } from "./package.types";
+
+export class EntityPackage {
+	private readonly packageName: string;
+	private packageJson: PackageJson | undefined;
+	constructor(packageName: string) {
+		this.packageName = packageName;
+		this.packageJson = this.readJson();
+	}
+
+	getName(): string {
+		return this.packageName;
+	}
+	isRoot(): boolean {
+		return this.getName() === "root";
+	}
+
+	getPath(): string {
+		if (this.packageName === "root") return ".";
+		if (this.packageName.startsWith("@repo/"))
+			return `packages/${this.packageName.replace("@repo/", "")}`;
+		return `apps/${this.packageName}`;
+	}
+
+	getJsonPath(): string {
+		return `${this.getPath()}/package.json`;
+	}
+	readJson(): PackageJson {
+		if (this.packageJson) {
+			return this.packageJson;
+		}
+
+		const jsonPath = this.getJsonPath();
+		try {
+			const packageJson = packagesShell.readJsonFile(jsonPath);
+			return packageJson;
+		} catch (error) {
+			throw new Error(`Package not found ${this.packageName} at ${this.getJsonPath()}: ${error}`);
+		}
+	}
+	async writeJson(data: PackageJson): Promise<void> {
+		await packagesShell.writeJsonFile(this.getJsonPath(), data);
+		this.packageJson = data;
+		await entitiesShell.runBiomeCheck(this.getJsonPath());
+	}
+
+	readVersion(): string | undefined {
+		return this.readJson().version;
+	}
+	async writeVersion(version: string): Promise<void> {
+		const packageJson = this.readJson();
+		packageJson.version = version;
+		this.packageJson = packageJson;
+		await this.writeJson(packageJson);
+	}
+
+	getTsconfigPath(): string {
+		return `${this.getPath()}/tsconfig.json`;
+	}
+	readTsconfig(): TsConfig {
+		const tsconfigPath = this.getTsconfigPath();
+		const content = packagesShell.readFileAsTextSync(tsconfigPath);
+		return JSON.parse(content);
+	}
+	async writeTsconfig(content: string): Promise<void> {
+		const tsconfigPath = this.getTsconfigPath();
+		await packagesShell.writeFileAsText(tsconfigPath, content);
+		await entitiesShell.runBiomeCheck(tsconfigPath);
+	}
+
+	getChangelogPath(): string {
+		return `${this.getPath()}/CHANGELOG.md`;
+	}
+	readChangelog(): string {
+		const changelogPath = this.getChangelogPath();
+		return packagesShell.readChangelogFile(changelogPath);
+	}
+	async writeChangelog(content: string): Promise<void> {
+		await packagesShell.writeChangelogFile(this.getChangelogPath(), content);
+		await entitiesShell.runBiomeCheck(this.getChangelogPath());
+	}
+
+	validatePackage(): string[] {
+		const packageJson = this.readJson();
+		const config = entitiesConfig.getConfig();
+		const errors: string[] = [];
+
+		// Only validate if package validation is enabled
+		if (!config.package) {
+			return errors;
+		}
+
+		const rules = config.package;
+
+		// Selective versioning rules
+		if (rules.selectiveVersioning.enabled) {
+			if (packageJson.private === true && packageJson.version) {
+				errors.push(`${this.packageName}: Private packages should not have version field`);
+			}
+			if (packageJson.private !== true && !packageJson.version) {
+				errors.push(`${this.packageName}: Versioned packages must have a version field`);
+			}
+			if (!packageJson.version && packageJson.private !== true) {
+				errors.push(`${this.packageName}: Unversioned packages must have private: true`);
+			}
+			if (packageJson.version && packageJson.private === true) {
+				errors.push(`${this.packageName}: Versioned packages should not have private: true`);
+			}
+		}
+
+		// Semantic versioning rules
+		if (rules.semanticVersioning.enabled && packageJson.version) {
+			if (!/^\d+\.\d+\.\d+$/.test(packageJson.version)) {
+				errors.push(`${this.packageName}: Version should follow semantic versioning (e.g., 1.0.0)`);
+			}
+		}
+
+		// Description rules
+		if (rules.description.enabled && packageJson.version && !packageJson.description) {
+			errors.push(`${this.packageName}: Consider adding a description to package.json`);
+		}
+
+		return errors;
+	}
+
+	/**
+	 * Determines if this package should be versioned based on its private field
+	 * @returns true if the package should be versioned (private !== true)
+	 */
+	shouldVersion(): boolean {
+		const packageJson = this.readJson();
+		// Package should be versioned if private is false or undefined
+		return packageJson.private !== true;
+	}
+
+	/**
+	 * Gets the tag series name for this package
+	 * @returns tag series prefix (e.g., 'v', 'intershell-v') or null if package shouldn't be versioned
+	 */
+	getTagSeriesName(): string | null {
+		if (!this.shouldVersion()) return null;
+
+		// Generate tag series name based on package name
+		if (this.packageName === "root") return "v";
+		return `${this.packageName.replace("@repo/", "")}-v`;
+	}
+
+	static getRepoUrl(): string {
+		const rootPackageJson = new EntityPackage("root").readJson();
+		return typeof rootPackageJson.repository === "string"
+			? rootPackageJson.repository
+			: rootPackageJson.repository?.url || "";
+	}
+	static async getAllPackages(): Promise<string[]> {
+		const packages: string[] = ["root"];
+
+		// Get workspace root
+		const workspaceRoot = await packagesShell.getWorkspaceRoot();
+
+		// Read apps directory
+		let apps: string[] = [];
+		try {
+			const appsPath = `${workspaceRoot}/apps`;
+			apps = await packagesShell.readDirectory(appsPath);
+		} catch {
+			// apps directory doesn't exist or can't be read
+		}
+
+		// Read packages directory
+		let pkgs: string[] = [];
+		try {
+			const packagesPath = `${workspaceRoot}/packages`;
+			const packageNames = await packagesShell.readDirectory(packagesPath);
+			pkgs = packageNames.map((name) => `@repo/${name}`);
+		} catch {
+			// packages directory doesn't exist or can't be read
+		}
+
+		// Filter packages that have valid package.json files
+		const filteredPackages = await Promise.all(
+			[...apps, ...pkgs].map(async (pkg) => {
+				const packageInstance = new EntityPackage(pkg);
+				const packageJsonPath = packageInstance.getJsonPath();
+
+				try {
+					const exists = await packagesShell.canAccessFile(packageJsonPath);
+					if (!exists) return null;
+
+					const packageJsonContent = await packagesShell.readFileAsText(packageJsonPath);
+					const packageJson = JSON.parse(packageJsonContent);
+					const name = packageJson.name;
+
+					if (!name) return null;
+
+					if (name !== pkg) {
+						throw new Error(`Package ${pkg} has a different name in package.json: ${name}`);
+					}
+
+					return name;
+				} catch {
+					return null;
+				}
+			}),
+		);
+
+		packages.push(...filteredPackages.filter((pkg): pkg is string => pkg !== null));
+
+		return packages;
+	}
+
+	/**
+	 * Gets all packages that should be versioned (private !== true)
+	 * @returns Array of package names that should be versioned
+	 */
+	static async getVersionedPackages(): Promise<string[]> {
+		const allPackages = await EntityPackage.getAllPackages();
+		const versionedPackages: string[] = [];
+
+		for (const packageName of allPackages) {
+			const packageInstance = new EntityPackage(packageName);
+			if (packageInstance.shouldVersion()) {
+				versionedPackages.push(packageName);
+			}
+		}
+
+		return versionedPackages;
+	}
+
+	/**
+	 * Gets all packages that should NOT be versioned (private === true)
+	 * @returns Array of package names that should NOT be versioned
+	 */
+	static async getUnversionedPackages(): Promise<string[]> {
+		const allPackages = await EntityPackage.getAllPackages();
+		const unversionedPackages: string[] = [];
+
+		for (const packageName of allPackages) {
+			const packageInstance = new EntityPackage(packageName);
+			if (!packageInstance.shouldVersion()) {
+				unversionedPackages.push(packageName);
+			}
+		}
+
+		return unversionedPackages;
+	}
+
+	/**
+	 * Validates all packages in the workspace
+	 * @returns Object containing validation results for all packages
+	 */
+	static async validateAllPackages(): Promise<string[]> {
+		const allPackages = await EntityPackage.getAllPackages();
+		const errors: Array<string> = [];
+
+		for (const packageName of allPackages) {
+			const packageInstance = new EntityPackage(packageName);
+			const packageErrors = packageInstance.validatePackage();
+
+			errors.push(...packageErrors);
+		}
+
+		return errors;
+	}
+}

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

@@ -0,0 +1,49 @@
+export interface PackageJson {
+	intershell?: {
+		config: string;
+	};
+	name: string;
+	version?: string; // Make version optional since private packages shouldn't have versions
+	description?: string;
+	main?: string;
+	scripts?: Record<string, string>;
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+	peerDependencies?: Record<string, string>;
+	author?: string;
+	license?: string;
+	repository?: string | RepositoryInfo;
+	bugs?: string | BugsInfo;
+	homepage?: string;
+	keywords?: string[];
+	private?: boolean;
+	workspaces?: string[];
+	[key: string]: unknown;
+}
+
+export interface TsConfigPaths {
+	readonly [key: string]: string[];
+}
+
+export interface TsConfig {
+	readonly extends?: string;
+	readonly compilerOptions?: {
+		readonly baseUrl?: string;
+		readonly paths?: TsConfigPaths;
+		readonly rootDir?: string;
+		readonly outDir?: string;
+		readonly references?: Array<{ readonly path: string }>;
+	};
+	readonly include?: string[];
+	readonly exclude?: string[];
+}
+
+export interface RepositoryInfo {
+	type: string;
+	url: string;
+}
+
+export interface BugsInfo {
+	url: string;
+	email?: string;
+}

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

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

package/src/entities/package-changelog/package-changelog.ts

@@ -0,0 +1,81 @@
+import type { ParsedCommitData } from "../commit";
+import type { EntityPackage } from "../package";
+import type { ChangelogData, VersionData } from "./package-changelog.types";
+import type { TemplateEngine } from "./template";
+
+export class EntityPackageChangelog {
+	private package: EntityPackage;
+	private template: TemplateEngine;
+	private versionMode: boolean;
+
+	private changelogData: ChangelogData | undefined;
+	private versionData: VersionData | undefined;
+
+	constructor(
+		packageInstance: EntityPackage,
+		commits: ParsedCommitData[],
+		options: { template: TemplateEngine; versionMode?: boolean; versionData?: VersionData },
+	) {
+		this.package = packageInstance;
+		this.template = options.template;
+		this.versionMode = options.versionMode ?? true;
+		this.versionData = options.versionData;
+		this.changelogData = this.getChangelogData(commits);
+	}
+
+	generateChangelog(): string {
+		if (!this.changelogData) {
+			throw new Error("Changelog data not generated.");
+		}
+		if (!this.template) {
+			throw new Error("Template engine not set.");
+		}
+
+		const changelog = this.template.generateContent(this.changelogData);
+		return changelog;
+	}
+
+	generateMergedChangelog(): string {
+		if (!this.changelogData) {
+			throw new Error("Data not analyzed. Call calculateRange() first.");
+		}
+		if (!this.versionData) {
+			throw new Error("Version data not determined. Call calculateRange() first.");
+		}
+		if (!this.template) {
+			throw new Error("Template engine not set.");
+		}
+
+		const mergedChangelogData: ChangelogData = new Map();
+
+		const existingChangelog = this.package.readChangelog();
+		const existingChangelogData = this.template.parseVersions(existingChangelog);
+
+		for (const [version, content] of existingChangelogData) {
+			mergedChangelogData.set(version, content);
+		}
+		for (const [version, content] of this.changelogData) {
+			mergedChangelogData.set(version, content);
+		}
+
+		const mergedChangelog = this.template.generateContent(mergedChangelogData);
+		return mergedChangelog;
+	}
+
+	private getChangelogData(commits: ParsedCommitData[]): ChangelogData {
+		const changelogData: ChangelogData = new Map();
+
+		if (commits.length === 0) {
+			return changelogData;
+		}
+
+		// Use target version if there's a version bump, otherwise use current version
+		const versionToUse = this.versionData?.shouldBump
+			? this.versionData.targetVersion
+			: this.package.readVersion() || "0.0.0";
+
+		changelogData.set(this.versionMode ? versionToUse : "[Unreleased]", commits);
+
+		return changelogData;
+	}
+}

package/src/entities/package-changelog/package-changelog.types.ts

@@ -0,0 +1,30 @@
+import type { ParsedCommitData } from "../commit";
+
+export type ChangelogData = Map<string, string | ParsedCommitData[]>;
+
+export type VersionBumpType = "major" | "minor" | "patch" | "none" | "synced";
+
+export interface VersionData {
+	readonly currentVersion: string;
+	readonly bumpType: VersionBumpType;
+	readonly shouldBump: boolean;
+	readonly targetVersion: string;
+	readonly reason: string;
+}
+
+export interface ChangelogSnapshot {
+	readonly versionData: VersionData;
+	readonly changelogData: ChangelogData;
+}
+
+export interface GitTagVersion {
+	readonly tag: string;
+	readonly version: string;
+	readonly commitHash: string;
+	readonly date: Date;
+}
+
+export interface PackageVersionHistory {
+	readonly packageName: string;
+	readonly versions: GitTagVersion[];
+}

package/src/entities/package-changelog/template.default.ts

@@ -0,0 +1,109 @@
+import { type ParsedCommitData, prCategories } from "../commit";
+import { entitiesConfig } from "../intershell-config/intershell-config";
+import { ChangelogTemplate } from "./template";
+
+const DEFAULT_BADGE_COLOR = "6B7280";
+const validTypes = entitiesConfig.getConfig().commit.conventional.type?.list ?? [];
+
+export class DefaultChangelogTemplate extends ChangelogTemplate {
+	protected generateChangelogHeader(): string {
+		return [
+			`## Changelog (${this.packageName})`,
+			"",
+			"[![Keep a Changelog](https://img.shields.io/badge/changelog-Keep%20a%20Changelog%20v1.0.0-$E05735)](https://keepachangelog.com)",
+			"[![Semantic Versioning](https://img.shields.io/badge/semver-semantic%20versioning%20v2.0.0-%23E05735)](https://semver.org)",
+			"",
+			"All notable changes to this project will be documented in this file.",
+			"The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),",
+			"and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).",
+			"",
+		].join("\n");
+	}
+
+	protected generateChangelogVersionHeader(version: string): string {
+		return ["", `## ${version === "[Unreleased]" ? "" : this.prefix}${version}`, ""].join("\n");
+	}
+
+	protected generateCommitSection(commit: ParsedCommitData, repoUrl: string): string {
+		if (commit.pr?.prNumber) {
+			return this.generatePrSection(commit, commit.pr.prCommits || [commit], repoUrl);
+		}
+
+		return `###### ${this.generateCommitLine(commit, repoUrl)}`;
+	}
+
+	private generatePrSection(
+		mainCommit: ParsedCommitData,
+		allCommits: ParsedCommitData[],
+		repoUrl: string,
+	): string {
+		const { pr: { prNumber, prCategory = "other", prBranchName } = {} } = mainCommit;
+		const commitCount = allCommits.length;
+
+		const categoryEmoji = prCategories[prCategory]?.emoji;
+		const categoryTitle = prCategories[prCategory]?.label;
+		const prCategoryBadge = `<img src="https://img.shields.io/badge/${encodeURIComponent(categoryTitle)}-495057?style=flat" alt="${categoryTitle}" style="vertical-align: middle;" />`;
+		const prNumberBadge =
+			!!prNumber &&
+			`<img src="https://img.shields.io/badge/%23${prNumber}-blue?style=flat" alt="#${prNumber}" style="vertical-align: middle;" />`;
+		const commitCountBadge = `<img src="https://img.shields.io/badge/${commitCount}%20commits-green?style=flat" alt="${commitCount} commits" style="vertical-align: middle;" />`;
+		const prNumberLink =
+			!!prNumberBadge && `<a href="${repoUrl}/pull/${prNumber}">${prNumberBadge}</a>`;
+
+		const prMessages = mainCommit.message.isMerge
+			? [
+					// mainCommit.message.bodyLines[0], // We don't want the first line: "Merge pull request #154 from feature/custom-version-management"
+					// "", // Empty line for separation, if you added the first line above, uncomment this line as well
+					...mainCommit.message.bodyLines.slice(1), // Rest of the lines: "Refactors the version management system..."
+				]
+			: [mainCommit.message.description, "", ...mainCommit.message.bodyLines];
+
+		return [
+			// Format: emoji branch-name category-title #PR-number commit-count
+			// Example: 🔄 refactor/test-versioning Code Quality & Refactoring #144 9 commits
+			"",
+			`### ${categoryEmoji} ${typeof prBranchName === "object" && prBranchName?.name ? prBranchName.name : typeof prBranchName === "string" ? prBranchName : "unknown-branch"} ${prCategoryBadge} ${prNumberLink} ${commitCountBadge}`,
+			"",
+			...prMessages,
+			"",
+			"<details><summary><strong>📝 Commits</strong> (Click to expand)</summary>",
+			"",
+			...allCommits.map((commit) => `- ${this.generateCommitLine(commit, repoUrl)}`),
+			"",
+			"</details>",
+			"",
+		].join("\n");
+	}
+
+	private generateCommitLine(commit: ParsedCommitData, repoUrl: string): string {
+		const {
+			info: { hash, author = "Unknown" } = {},
+			message: { type, description, scopes = [] },
+		} = commit;
+
+		const hashKey = hash?.substring(0, 7) || "unknown";
+		const hashUrl = hash ? `${repoUrl}/commit/${hash}` : undefined;
+
+		const scopeSection =
+			scopes && scopes.length > 0
+				? scopes.map((s: string) => s.toLowerCase().replace("-", "%20")).join(",")
+				: "";
+
+		const badgeText = `${type}-(${scopeSection || "noscope"})`;
+		const badgeColor = validTypes.find((t) => t.type === type)?.badgeColor || DEFAULT_BADGE_COLOR;
+		const badge = `<img src="https://img.shields.io/badge/${badgeText}-${badgeColor}?style=flat" alt="${type}" style="vertical-align: middle;" />`;
+		const badgeUrl = hashUrl ? `<a href="${hashUrl}">${badge}</a>` : badge;
+
+		const hashLink = hashUrl ? `([${hashKey}](${hashUrl}))` : `[${hashKey}]`;
+
+		return [
+			badgeUrl,
+			description,
+			hashLink,
+			author && (author.includes("@") ? `by [${author}](mailto:${author})` : `by **${author}**`),
+		]
+			.filter(Boolean)
+			.join(" ")
+			.trim();
+	}
+}

package/src/entities/package-changelog/template.ts

@@ -0,0 +1,118 @@
+import type { ParsedCommitData } from "../commit";
+import { EntityPackage } from "../package";
+import type { ChangelogData } from "./package-changelog.types";
+
+export interface TemplateEngine {
+	generateContent(data: ChangelogData): string;
+	parseVersions(content: string): ChangelogData;
+	sortVersions(versionA: string, versionB: string): number;
+}
+export type TemplateEngineData = ChangelogData;
+
+const repoUrl = EntityPackage.getRepoUrl();
+
+export class ChangelogTemplate implements TemplateEngine {
+	readonly packageName: string;
+	readonly prefix: string;
+
+	constructor(packageName: string, prefix: string) {
+		this.packageName = packageName;
+		this.prefix = prefix;
+	}
+
+	generateContent(changelogData: TemplateEngineData): string {
+		let changelog = this.generateChangelogHeader(this.packageName);
+
+		const sortedVersions = Array.from(changelogData.keys()).sort((a, b) => this.sortVersions(b, a));
+		for (const version of sortedVersions) {
+			const commits = changelogData.get(version) || [];
+			if (typeof commits === "string") {
+				changelog += `\n${commits}`;
+				continue;
+			}
+
+			const versionHeader = this.generateChangelogVersionHeader(version);
+			changelog += versionHeader;
+			changelog += commits.map((commit) => this.generateCommitSection(commit, repoUrl)).join("\n");
+		}
+
+		return changelog;
+	}
+
+	parseVersions(content: string): TemplateEngineData {
+		const versions: TemplateEngineData = new Map();
+		const lines = content.split("\n");
+		const headerEnd = lines.findIndex((line, i) => i > 0 && line.startsWith("## "));
+
+		if (headerEnd === -1) return versions;
+
+		let currentVersion = "";
+		let currentContent: string[] = [];
+
+		for (let i = headerEnd; i < lines.length; i++) {
+			const line = lines[i];
+			const isVersionLine =
+				line.match(/## \[Unreleased\]/) ||
+				line.match(new RegExp(`^## ${this.prefix}?\\d+\\.\\d+\\.\\d+`));
+
+			if (isVersionLine) {
+				if (currentVersion) {
+					versions.set(currentVersion, currentContent.join("\n"));
+				}
+
+				// Extract clean version number from the header line
+				let cleanVersion = line;
+				if (line.includes("[Unreleased]")) {
+					cleanVersion = "[Unreleased]";
+				} else {
+					// Extract version from "## v1.2.3" or "## intershell-v1.2.3" format
+					const versionMatch = line.match(new RegExp(`## (${this.prefix}\\d+\\.\\d+\\.\\d+)`));
+					if (versionMatch) {
+						cleanVersion = versionMatch[1].replace(this.prefix, "");
+					}
+				}
+
+				currentVersion = cleanVersion;
+				currentContent = [line];
+			} else {
+				currentContent.push(line);
+			}
+		}
+
+		if (currentVersion) {
+			versions.set(currentVersion, currentContent.join("\n"));
+		}
+
+		return versions;
+	}
+
+	sortVersions(versionA: string, versionB: string): number {
+		const partsA = versionA.split(".").map(Number);
+		const partsB = versionB.split(".").map(Number);
+
+		while (partsA.length < 3) partsA.push(0);
+		while (partsB.length < 3) partsB.push(0);
+
+		if (partsA[0] !== partsB[0]) {
+			return partsA[0] - partsB[0]; // Descending order (newest first)
+		}
+
+		if (partsA[1] !== partsB[1]) {
+			return partsA[1] - partsB[1]; // Descending order
+		}
+
+		return partsA[2] - partsB[2]; // Descending order
+	}
+
+	protected generateChangelogHeader(_packageName: string): string {
+		return "";
+	}
+
+	protected generateChangelogVersionHeader(_version: string): string {
+		return "";
+	}
+
+	protected generateCommitSection(_commit: ParsedCommitData, _repoUrl: string): string {
+		return "";
+	}
+}

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

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import { EntityPackage } from "../package";
+import { EntityDependencyAnalyzer } from "./dependency-analyzer";
+
+describe("EntityDependencyAnalyzer", () => {
+	test("should create instance", () => {
+		const packageInstance = new EntityPackage("root");
+		const analyzer = new EntityDependencyAnalyzer(packageInstance);
+		expect(analyzer).toBeDefined();
+	});
+
+	test("should get package dependencies at ref", async () => {
+		const packageInstance = new EntityPackage("root");
+		const analyzer = new EntityDependencyAnalyzer(packageInstance);
+
+		// This will return empty array since we can't mock git operations easily
+		const deps = await analyzer.getPackageDependenciesAtRef("HEAD");
+		expect(Array.isArray(deps)).toBe(true);
+	});
+
+	test("should handle dependencies", async () => {
+		const packageInstance = new EntityPackage("root");
+		const analyzer = new EntityDependencyAnalyzer(packageInstance);
+
+		const deps = await analyzer.getPackageDependenciesAtRef("HEAD");
+		expect(Array.isArray(deps)).toBe(true);
+		// Root package might have dependencies, so we just check it's an array
+	});
+});