@afoures/auto-release 0.3.0 → 0.4.1

package/README.md

@@ -19,7 +19,7 @@ Release management should be simple. `auto-release` lets you focus on building f
 ```bash
 npx @afoures/auto-release@latest init
 # or
-pnpx @afoures/auto-release@latest init
+pnpm dlx @afoures/auto-release@latest init
 # or
 yarn dlx @afoures/auto-release@latest init
 # or

package/dist/lib/commands/check.mjs

@@ -45,6 +45,27 @@ async function validate_changes_files_content(changes_dir, project) {
 	};
 	return { ok: true };
 }
+function validate_groups(projects) {
+	const errors = [];
+	const warnings = [];
+	const group_names = new Set(projects.map((p) => p.release_group));
+	for (const group_name of group_names) {
+		const project_with_same_name = projects.find((p) => p.name === group_name);
+		if (project_with_same_name && project_with_same_name.release_group !== group_name) errors.push(`Group name "${group_name}" conflicts with project name. Groups and projects must have unique names.`);
+	}
+	const group_names_array = Array.from(group_names);
+	for (let i = 0; i < group_names_array.length; i++) for (let j = i + 1; j < group_names_array.length; j++) {
+		const group_a = group_names_array[i];
+		const group_b = group_names_array[j];
+		if (group_a.toLowerCase() === group_b.toLowerCase() && group_a !== group_b) warnings.push(`Groups "${group_a}" and "${group_b}" have similar names (case insensitive match). Consider using consistent casing.`);
+	}
+	const special_char_pattern = /[^a-zA-Z0-9_-]/;
+	for (const group_name of group_names) if (special_char_pattern.test(group_name)) warnings.push(`Group name "${group_name}" contains special characters. Consider using only alphanumeric, hyphens, and underscores for compatibility.`);
+	return {
+		errors,
+		warnings
+	};
+}
 const check = create_command({
 	name: "check",
 	description: "Validate configuration, versions, and change files",
@@ -62,7 +83,11 @@ const check = create_command({
 	run: async ({ context }) => {
 		const logger = create_logger();
 		const errors = [];
+		const warnings = [];
 		const config = context.config;
+		const group_validation = validate_groups(config.managed_projects);
+		errors.push(...group_validation.errors);
+		warnings.push(...group_validation.warnings);
 		for (const project of config.managed_projects) {
 			const component_validation = await verify_component_version_consistency(project);
 			if (!component_validation.ok) errors.push(...component_validation.errors);
@@ -70,10 +95,17 @@ const check = create_command({
 			if (!changes_validation.ok) errors.push(...changes_validation.errors);
 		}
 		const valid = errors.length === 0;
-		if (valid) logger.success("All validations passed!");
-		else {
+		if (valid && warnings.length === 0) logger.success("All validations passed!");
+		else if (valid) {
+			logger.warn("Validations passed with warnings:");
+			warnings.forEach((warning) => logger.warn(`  ${warning}`));
+		} else {
 			logger.error("Detected errors:");
 			errors.forEach((err) => logger.error(`  ${err}`));
+			if (warnings.length > 0) {
+				logger.warn("Warnings:");
+				warnings.forEach((warning) => logger.warn(`  ${warning}`));
+			}
 		}
 		if (valid) return {
 			status: "success",

package/dist/lib/commands/generate-release-pr.mjs

@@ -6,6 +6,7 @@ import { find_change_files } from "../change-file.mjs";
 import { diff, reset } from "../utils/git.mjs";
 import { compute_current_version } from "../utils/version.mjs";
 import { parse_markdown } from "../utils/mdast.mjs";
+import { group_projects } from "../utils/group.mjs";
 import { join } from "node:path";
 
 //#region src/lib/commands/generate-release-pr.ts
@@ -17,11 +18,6 @@ const generate_release_pr = create_command({
 			type: "string",
 			description: "Path to config file"
 		},
-		filter: {
-			type: "string",
-			description: "Only generate release PRs for the specified projects",
-			multiple: true
-		},
 		"dry-run": {
 			type: "boolean",
 			description: "Show what would be done without making changes"
@@ -37,79 +33,21 @@ const generate_release_pr = create_command({
 			root: git_root || config.folder
 		};
 	},
-	run: async ({ args: { filter, "dry-run": dry_run = false }, context: { config, root } }) => {
+	run: async ({ args: { "dry-run": dry_run = false }, context: { config, root } }) => {
 		const logger = create_logger();
-		const filtered_projects = filter ? config.managed_projects.filter((project) => filter.includes(project.name)) : config.managed_projects;
-		if (filtered_projects.length === 0) return {
+		const project_groups = group_projects(config.managed_projects);
+		if (project_groups.length === 0) return {
 			status: "success",
 			message: "No projects to release"
 		};
-		for (const project of filtered_projects) {
-			const changes_dir = join(config.changes_dir, project.name);
-			const changes = await find_change_files(changes_dir, { allowed_kinds: project.versioning.allowed_changes });
-			if (changes.warnings.length > 0) for (const warning of changes.warnings) logger.warn(warning);
-			const current_version = await compute_current_version(project, { get_file_content: (file_path) => read_file(file_path) }) ?? project.versioning.initial_version;
-			const next_version = project.versioning.bump({
-				version: current_version,
-				changes: changes.list,
-				date: /* @__PURE__ */ new Date()
-			});
-			const changes_by_kind = /* @__PURE__ */ new Map();
-			for (const change of changes.list) {
-				const existing = changes_by_kind.get(change.kind) ?? [];
-				existing.push(change);
-				changes_by_kind.set(change.kind, existing);
-			}
-			const message_lines = [];
-			const display_map = project.versioning.display_map;
-			for (const [kind, kind_changes] of changes_by_kind.entries()) {
-				const label = display_map[kind]?.plural ?? display_map[kind]?.singular ?? kind;
-				message_lines.push(`\n${label}:`);
-				for (const change of kind_changes) message_lines.push(`  ${change.summary}`);
-			}
-			logger.note(`Release ${project.name} ${next_version}`, message_lines.join("\n"));
-			if (dry_run) continue;
-			await delete_all_files_from_folder(changes_dir);
-			for (const component of project.components) for (const part of component.parts) {
-				const initial_content = await read_file(part.file);
-				if (initial_content === null) continue;
-				const updated_content = part.update_version(initial_content, next_version);
-				await write_file(part.file, updated_content);
-			}
-			const formatter = project.versioning.formatter;
-			const initial_changelog_content = await read_file(project.changelog);
-			const changelog_as_mdast = parse_markdown(initial_changelog_content ?? "");
-			const changelog = formatter.transform_markdown(changelog_as_mdast, initial_changelog_content ?? "");
-			const updated_changelog_content = formatter.format_changelog({
-				...changelog,
-				releases: [{
-					version: next_version,
-					changes: changes.list
-				}, ...changelog.releases.filter((release) => release.version !== next_version)].sort((a, b) => project.versioning.compare(b.version, a.version))
-			}, { project: { name: project.name } });
-			await write_file(project.changelog, updated_changelog_content);
-			const file_operations = await diff(root);
-			await reset(root);
-			const platform = config.git.platform;
-			const release_branch_name = `${config.git.default_release_branch_prefix}/${project.name}`;
-			await platform.create_or_update_branch({
-				branch_name: release_branch_name,
-				base_branch_name: config.git.target_branch,
-				file_operations,
-				commit_message: `chore: prepare release ${project.name}@${next_version}`
-			});
-			await platform.create_or_update_pull_request({
-				head_branch_name: release_branch_name,
-				base_branch_name: config.git.target_branch,
-				title: `release: ${project.name}@${next_version}`,
-				body: formatter.generate_pr_body({
-					project: { name: project.name },
-					current_version,
-					next_version,
-					changes: changes.list
-				}),
-				draft: true
-			});
+		for (const group of project_groups) if (await release_group(group, {
+			config,
+			root,
+			dry_run,
+			logger
+		}) === "skipped") {
+			logger.info(`Skipping group "${group.name}" - no projects with changes`);
+			continue;
 		}
 		if (dry_run) return {
 			status: "success",
@@ -121,6 +59,108 @@ const generate_release_pr = create_command({
 		};
 	}
 });
+async function release_group(group, { config, root, dry_run, logger }) {
+	const project_releases = [];
+	for (const project of group.projects) {
+		const changes_dir = join(config.changes_dir, project.name);
+		const changes_result = await find_change_files(changes_dir, { allowed_kinds: project.versioning.allowed_changes });
+		if (changes_result.warnings.length > 0) for (const warning of changes_result.warnings) logger.warn(warning);
+		if (project.options.skip_release_if_no_change_file && changes_result.list.length === 0) continue;
+		const current_version = await compute_current_version(project, { get_file_content: (file_path) => read_file(file_path) }) ?? project.versioning.initial_version;
+		const next_version = project.versioning.bump({
+			version: current_version,
+			changes: changes_result.list,
+			date: /* @__PURE__ */ new Date()
+		});
+		const changes_by_kind = /* @__PURE__ */ new Map();
+		for (const change of changes_result.list) {
+			const existing = changes_by_kind.get(change.kind) ?? [];
+			existing.push(change);
+			changes_by_kind.set(change.kind, existing);
+		}
+		const message_lines = [];
+		const display_map = project.versioning.display_map;
+		for (const [kind, kind_changes] of changes_by_kind.entries()) {
+			const label = display_map[kind]?.plural ?? display_map[kind]?.singular ?? kind;
+			message_lines.push(`\n${label}:`);
+			for (const change of kind_changes) message_lines.push(`  ${change.summary}`);
+		}
+		logger.note(`Release ${project.name} ${next_version}`, message_lines.join("\n"));
+		if (dry_run) continue;
+		const file_operations = await collect_project_file_operations(project, {
+			changes_dir,
+			changes: changes_result.list,
+			current_version,
+			next_version,
+			root
+		});
+		project_releases.push({
+			project,
+			current_version,
+			next_version,
+			changes: changes_result.list,
+			file_operations
+		});
+	}
+	if (project_releases.length === 0) return "skipped";
+	if (dry_run) return "processed";
+	const all_file_operations = project_releases.flatMap((release) => release.file_operations);
+	const pr_title = generate_pr_title(project_releases);
+	const platform = config.git.platform;
+	const release_branch_name = `${config.git.default_release_branch_prefix}/${group.name}`;
+	await platform.create_or_update_branch({
+		branch_name: release_branch_name,
+		base_branch_name: config.git.target_branch,
+		file_operations: all_file_operations,
+		commit_message: pr_title
+	});
+	const pr_body = generate_pr_body(project_releases);
+	await platform.create_or_update_pull_request({
+		head_branch_name: release_branch_name,
+		base_branch_name: config.git.target_branch,
+		title: pr_title,
+		body: pr_body,
+		draft: true
+	});
+	return "processed";
+}
+async function collect_project_file_operations(project, { changes_dir, changes, current_version: _current_version, next_version, root }) {
+	await delete_all_files_from_folder(changes_dir);
+	for (const component of project.components) for (const part of component.parts) {
+		const initial_content = await read_file(part.file);
+		if (initial_content === null) continue;
+		const updated_content = part.update_version(initial_content, next_version);
+		await write_file(part.file, updated_content);
+	}
+	const formatter = project.versioning.formatter;
+	const initial_changelog_content = await read_file(project.changelog);
+	const changelog_as_mdast = parse_markdown(initial_changelog_content ?? "");
+	const changelog = formatter.transform_markdown(changelog_as_mdast, initial_changelog_content ?? "");
+	const updated_changelog_content = formatter.format_changelog({
+		...changelog,
+		releases: [{
+			version: next_version,
+			changes
+		}, ...changelog.releases.filter((release) => release.version !== next_version)].sort((a, b) => project.versioning.compare(b.version, a.version))
+	}, { project: { name: project.name } });
+	await write_file(project.changelog, updated_changelog_content);
+	const file_operations = await diff(root);
+	await reset(root);
+	return file_operations;
+}
+function generate_pr_body(project_releases) {
+	return ["This PR is managed by [auto-release](https://github.com/afoures/auto-release). Do not edit it manually.", ...project_releases.map((release) => {
+		return release.project.versioning.formatter.generate_pr_body({
+			project: { name: release.project.name },
+			current_version: release.current_version,
+			next_version: release.next_version,
+			changes: release.changes
+		});
+	})].join("\n\n");
+}
+function generate_pr_title(project_releases) {
+	return `release: ${project_releases.map((release) => `${release.project.name}@${release.next_version}`).join(", ")}`;
+}
 
 //#endregion
 export { generate_release_pr };

package/dist/lib/commands/list.mjs

@@ -3,6 +3,7 @@ import { create_logger } from "../utils/logger.mjs";
 import { read_file } from "../utils/fs.mjs";
 import { find_nearest_config } from "../config.mjs";
 import { compute_current_version } from "../utils/version.mjs";
+import { group_projects, is_multi_project_group } from "../utils/group.mjs";
 import { relative } from "node:path";
 
 //#region src/lib/commands/list.ts
@@ -30,21 +31,29 @@ const list = create_command({
 			logger.info("no projects registered.");
 			return { status: "success" };
 		}
+		const project_groups = group_projects(config.managed_projects);
 		const count = config.managed_projects.length;
+		const group_count = project_groups.length;
 		const warnings = [];
-		logger.info(`found ${count} project${count > 1 ? "s" : ""}:`);
+		logger.info(`found ${count} project${count > 1 ? "s" : ""} in ${group_count} group${group_count > 1 ? "s" : ""}:`);
 		logger.info("");
-		for (const project of config.managed_projects) {
-			const version = await compute_current_version(project, { get_file_content: (file_path) => read_file(file_path) });
-			if (version === null) {
-				warnings.push(`${project.name} has no version`);
-				continue;
+		for (const group of project_groups) {
+			const is_multi = is_multi_project_group(group);
+			logger.info(`Group: ${group.name} (${group.projects.length} project${group.projects.length > 1 ? "s" : ""})`);
+			for (const project of group.projects) {
+				const version = await compute_current_version(project, { get_file_content: (file_path) => read_file(file_path) });
+				if (version === null) {
+					warnings.push(`${project.name} has no version`);
+					continue;
+				}
+				const parts = project.components.flatMap((component) => component.parts.map((part) => ({
+					relative_path: relative(root, part.file),
+					missing: part.exists === false
+				})));
+				const indent = is_multi ? "  " : "";
+				logger.info(`${indent}${project.name} (${version})`);
+				for (const part of parts) logger.info(`${indent}  ./${part.relative_path}${part.missing ? " ⚠️ missing" : ""}`);
 			}
-			const parts = project.components.flatMap((component) => component.parts.map((part) => ({
-				relative_path: relative(root, part.file),
-				missing: part.exists === false
-			})));
-			logger.note(`${project.name} (${version})`, parts.map((part) => `./${part.relative_path} ${part.missing ? "⚠️ missing" : ""}`).join("\n"));
 			logger.info("");
 		}
 		return {

package/dist/lib/config.mjs

@@ -43,7 +43,9 @@ var InternalConfig = class {
 			return {
 				name,
 				...definition,
-				components
+				components,
+				release_group: definition.release_group || this.#config.default_project_config?.release_group || name,
+				options: { skip_release_if_no_change_file: definition.options?.skip_release_if_no_change_file || this.#config.default_project_config?.options?.skip_release_if_no_change_file || false }
 			};
 		});
 	}

package/dist/lib/formatter.mjs

@@ -114,8 +114,7 @@ function default_formatter({ allowed_changes, display_map }) {
 		},
 		generate_pr_body({ project, current_version, next_version, changes }) {
 			const lines = [];
-			lines.push("This PR is managed by `[auto-release](https://github.com/afoures/auto-release)`. Do not edit it manually.");
-			lines.push(`## Automated release for \`${project.name}\``);
+			lines.push(`# Automated release for \`${project.name}\``);
 			lines.push(`Version: \`${current_version}\` → \`${next_version}\``);
 			lines.push("");
 			lines.push("## Changelog");

package/dist/lib/platforms/github.mjs

@@ -37,8 +37,15 @@ function github(options) {
 				files_to_delete.add(op.previous_path);
 			}
 			const tree_entries = [];
-			for (const entry of base_tree.tree || []) if (entry.type === "blob" && !files_to_delete.has(entry.path)) {
-				if (!files_to_modify.has(entry.path)) tree_entries.push({
+			for (const entry of base_tree.tree || []) {
+				if (entry.type !== "blob") continue;
+				if (files_to_delete.has(entry.path)) tree_entries.push({
+					path: entry.path,
+					mode: "100644",
+					type: "blob",
+					sha: null
+				});
+				else if (!files_to_modify.has(entry.path)) tree_entries.push({
 					path: entry.path,
 					mode: "100644",
 					type: "blob",

package/dist/lib/types.d.mts

@@ -20,6 +20,12 @@ interface AutoReleaseConfig {
       version: string;
     }) => string;
   };
+  default_project_config?: {
+    release_group?: string;
+    options?: {
+      skip_release_if_no_change_file?: boolean;
+    };
+  };
   projects: Record<string, ProjectDefinition>;
 }
 /**
@@ -29,12 +35,20 @@ interface ProjectDefinition {
   components: Array<Component>;
   versioning: VersionManager;
   changelog: string;
+  release_group?: string;
+  options?: {
+    skip_release_if_no_change_file?: boolean;
+  };
 }
 type ManagedProject = {
   name: string;
   components: Array<ResolvedComponent>;
   versioning: VersionManager;
   changelog: string;
+  release_group: string;
+  options: {
+    skip_release_if_no_change_file: boolean;
+  };
 };
 //#endregion
 export { AutoReleaseConfig, ManagedProject };

package/dist/lib/utils/group.mjs

@@ -0,0 +1,19 @@
+//#region src/lib/utils/group.ts
+function group_projects(projects) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const project of projects) {
+		const existing = groups.get(project.release_group) ?? [];
+		existing.push(project);
+		groups.set(project.release_group, existing);
+	}
+	return [...groups.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, group_projects$1]) => ({
+		name,
+		projects: group_projects$1.sort((a, b) => a.name.localeCompare(b.name))
+	}));
+}
+function is_multi_project_group(group) {
+	return group.projects.length > 1;
+}
+
+//#endregion
+export { group_projects, is_multi_project_group };

package/docs/commands.md

@@ -12,12 +12,20 @@ Interactively configures projects, versioning strategies, and git platform.
 
 ## `check`
 
-Validate configuration and change files:
+Validate configuration, change files, and release groups:
 
 ```bash
 auto-release check
 ```
 
+**Validations:**
+
+- Component version consistency
+- Change file content
+- Group name conflicts (group names cannot match project names)
+- Similar group names (case-insensitive)
+- Group name special characters
+
 Use in CI to ensure everything is valid before merging.
 
 ## `record-change`
@@ -34,15 +42,31 @@ auto-release record-change --project my-app --type minor
 
 ## `list`
 
-List all projects managed by `auto-release` with their current versions:
+List all projects managed by `auto-release` with their current versions, grouped by `release_group`:
 
 ```bash
 auto-release list
 ```
 
+**Output example:**
+
+```
+found 5 projects in 3 groups:
+
+Group: frontend (2 projects)
+  web-app (1.2.3)
+    ./apps/web/package.json
+  mobile-app (2.0.1)
+    ./apps/mobile/package.json
+
+Group: api-service (1 project)
+  api-service (0.5.0)
+    ./services/api/Cargo.toml
+```
+
 ## `generate-release-pr`
 
-Create or update release PRs:
+Create or update release PRs based on change files:
 
 ```bash
 # Preview changes
@@ -50,11 +74,16 @@ auto-release generate-release-pr --dry-run
 
 # Create/update PRs
 auto-release generate-release-pr
-
-# Specific projects only
-auto-release generate-release-pr --filter my-app --filter another-app
 ```
 
+Projects are grouped by `release_group` in the configuration. Projects in the same group are released together in a single PR.
+
+**PR Structure:**
+
+- **Branch**: `release/<group-name>` (e.g., `release/frontend`)
+- **Title**: `release: project-a@1.0.0, project-b@2.0.0` (lists all projects with versions)
+- **Body**: Contains sections for each project's changelog
+
 ## `tag-release-commit`
 
 Create git tags and releases for version changes:

package/docs/configuration.md

@@ -22,6 +22,85 @@ projects: {
 }
 ```
 
+## Grouping Projects
+
+Projects can be grouped to release together in a single pull/merge request using the `release_group` option.
+
+### Default Behavior
+
+By default, each project is its own group (releases individually). The group name defaults to the project name.
+
+### Custom Groups
+
+```typescript
+export default define_config({
+  projects: {
+    "web-app": {
+      release_group: "frontend",  // Groups with other "frontend" projects
+      components: [...],
+      versioning: semver(),
+      changelog: "./CHANGELOG.md",
+    },
+    "mobile-app": {
+      release_group: "frontend",  // Same group - released together
+      components: [...],
+      versioning: semver(),
+      changelog: "./CHANGELOG.md",
+    },
+    "api": {
+      // No release_group - defaults to "api" (individual release)
+      components: [...],
+      versioning: semver(),
+      changelog: "./CHANGELOG.md",
+    },
+  },
+});
+```
+
+**Resulting behavior:**
+
+- Changes to `web-app` or `mobile-app` create a single PR with both projects
+- Changes to `api` create an individual PR
+- Branch name: `release/frontend` for grouped, `release/api` for individual
+- PR title: `release: web-app@1.2.0, mobile-app@2.0.0` for grouped
+
+### Default Project Config
+
+Set default options for all projects:
+
+```typescript
+export default define_config({
+  default_project_config: {
+    release_group: "shared",  // All projects default to this group
+    options: {
+      skip_release_if_no_change_file: true,
+    },
+  },
+  projects: { ... },
+});
+```
+
+### Options
+
+#### `skip_release_if_no_change_file`
+
+When `true`, skip creating a release PR for projects without change files.
+
+```typescript
+projects: {
+  "my-app": {
+    components: [...],
+    versioning: semver(),
+    changelog: "CHANGELOG.md",
+    options: {
+      skip_release_if_no_change_file: true,
+    },
+  },
+}
+```
+
+Useful for grouped projects where some projects may not have changes in every release cycle.
+
 ## Versioning Strategies
 
 ```typescript

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@afoures/auto-release",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A file based release management tool for monorepos",
   "homepage": "https://github.com/afoures/auto-release#readme",
   "bugs": {
     "url": "https://github.com/afoures/auto-release/issues"
   },
+  "license": "MIT",
   "author": "Antoine Fourès <contact@afoures.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/afoures/auto-release.git"
   },
-  "license": "MIT",
   "bin": {
     "auto-release": "./dist/bin.mjs"
   },
@@ -21,6 +21,7 @@
     "package.json",
     "README.md"
   ],
+  "keywords": [],
   "type": "module",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -72,6 +73,7 @@
     "test": "vitest",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint",
-    "format": "oxfmt"
+    "format": "oxfmt",
+    "auto-release.local": "node ./dist/bin.mjs"
   }
 }