@doryski/release 1.0.0 → 1.1.1

package/README.md

@@ -37,6 +37,7 @@ pnpm release
 | `-r, --release-version <ver>` | Exact release version (`0.2.0` or `v0.2.0`). Highest precedence. |
 | `--bump <major\|minor\|patch>` | Force the bump level. Overrides the auto-detected level; ignored when `--release-version` is set. |
 | `-y, --yes` | Skip the confirmation prompt (required for non-interactive runs). |
+| `--no-changelog` | Skip cutting a `CHANGELOG.md` section for this release. |
 | `-n, --dry-run` | Preview actions without modifying files, committing, tagging, or pushing. |
 | `-h, --help` | Show help. |
 
@@ -48,6 +49,34 @@ The auto-detected bump follows conventional commits since the latest tag:
 - any `feat:` → **minor**
 - everything else (`fix`, `chore`, `docs`, …) → **patch**
 
+## Changelog
+
+If the repo has a `CHANGELOG.md`, the CLI cuts a dated section for the release
+and includes it in the `release: vX.Y.Z` commit, so the file can never drift
+behind the tags. Repos without the file are unaffected; `--no-changelog` opts
+out.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/): the new
+section goes directly below `## [Unreleased]`, which is left in place, empty and
+ready for the next cycle.
+
+Section content comes from one of two places:
+
+- **Hand-written notes win.** Anything under `## [Unreleased]` is promoted
+  verbatim into the new version section. Write prose there as you go and the
+  release just files it under the right version.
+- **Otherwise it is generated** from the conventional commits since the last
+  tag: `feat` → `### Added`, `fix` → `### Fixed`, `perf`/`refactor`/`revert` →
+  `### Changed`, and anything marked `!` or carrying a `BREAKING CHANGE:` footer
+  → `### Breaking Changes`. Scopes render as a bold prefix. Non-user-facing
+  types (`chore`, `docs`, `test`, `ci`, `build`, `style`, `release`) are dropped.
+
+Link references are maintained only where the document already uses them: a
+`[X.Y.Z]: …/releases/tag/vX.Y.Z` entry is added for the new version, and an
+`[Unreleased]: …/compare/vX.Y.Z...HEAD` entry is repointed at it.
+
+When neither source yields anything, `CHANGELOG.md` is left untouched.
+
 ## Programmatic use
 
 ```ts

package/dist/{chunk-67J7X3FS.js → chunk-EBHQERFN.js}

@@ -1,5 +1,148 @@
+// src/changelog.ts
+import { readFile, writeFile } from "fs/promises";
+
+// src/semver.ts
+var parseSemver = (tag) => {
+  const match = /^v(\d+)\.(\d+)\.(\d+)(?:-([\w.-]+))?$/.exec(tag);
+  if (!match) return null;
+  const [, major, minor, patch, prerelease] = match;
+  return {
+    major: Number(major),
+    minor: Number(minor),
+    patch: Number(patch),
+    prerelease: prerelease ?? null
+  };
+};
+var applyBump = (v, type) => {
+  if (type === "major") return `v${v.major + 1}.0.0`;
+  if (type === "minor") return `v${v.major}.${v.minor + 1}.0`;
+  return `v${v.major}.${v.minor}.${v.patch + 1}`;
+};
+var determineBump = (commits) => {
+  let bump = "patch";
+  const subjectRe = /^(\w+)(?:\([^)]*\))?(!)?:/;
+  for (const msg of commits) {
+    const subject = msg.split("\n")[0];
+    const match = subjectRe.exec(subject);
+    const breaking = match?.[2] === "!" || /^BREAKING CHANGE:/m.test(msg);
+    if (breaking) return "major";
+    if (match?.[1] === "feat") bump = "minor";
+  }
+  return bump;
+};
+var stripV = (tag) => tag.startsWith("v") ? tag.slice(1) : tag;
+
+// src/changelog.ts
+var SECTION_BY_TYPE = {
+  feat: "Added",
+  fix: "Fixed",
+  perf: "Changed",
+  refactor: "Changed",
+  revert: "Changed"
+};
+var BREAKING_SECTION = "Breaking Changes";
+var SECTION_ORDER = [
+  BREAKING_SECTION,
+  "Added",
+  "Changed",
+  "Fixed"
+];
+var SUBJECT_RE = /^(\w+)(?:\(([^)]*)\))?(!)?:\s*(.+)$/;
+var isKnownType = (type) => type in SECTION_BY_TYPE;
+var parseCommit = (message) => {
+  const [subject = "", ...rest] = message.split("\n");
+  const match = SUBJECT_RE.exec(subject.trim());
+  if (!match) return null;
+  const [, type, scope, bang, description] = match;
+  const breaking = bang === "!" || /^BREAKING CHANGE:/m.test(rest.join("\n"));
+  if (breaking) return { section: BREAKING_SECTION, scope: scope ?? null, description };
+  if (!isKnownType(type)) return null;
+  return { section: SECTION_BY_TYPE[type], scope: scope ?? null, description };
+};
+var renderEntry = ({ scope, description }) => scope ? `- **${scope}**: ${description}` : `- ${description}`;
+var renderEntries = (commits) => {
+  const entries = commits.map(parseCommit).filter((entry) => entry !== null);
+  return SECTION_ORDER.flatMap((section) => {
+    const forSection = entries.filter((entry) => entry.section === section);
+    if (!forSection.length) return [];
+    return [`### ${section}`, "", ...forSection.map(renderEntry), ""];
+  }).join("\n").trimEnd();
+};
+var VERSION_HEADING_RE = /^## \[/;
+var UNRELEASED_HEADING_RE = /^## \[unreleased\]/i;
+var splitDocument = (content) => {
+  const lines = content.split("\n");
+  const headings = lines.flatMap(
+    (line, index) => VERSION_HEADING_RE.test(line) ? [index] : []
+  );
+  const unreleasedAt = headings.find(
+    (index) => UNRELEASED_HEADING_RE.test(lines[index])
+  );
+  if (unreleasedAt === void 0) {
+    const at = headings[0] ?? lines.length;
+    return {
+      head: lines.slice(0, at).join("\n"),
+      unreleasedHeading: null,
+      unreleasedBody: "",
+      tail: lines.slice(at).join("\n")
+    };
+  }
+  const tailAt = headings.find(
+    (index) => index > unreleasedAt && !UNRELEASED_HEADING_RE.test(lines[index])
+  ) ?? lines.length;
+  return {
+    head: lines.slice(0, unreleasedAt).join("\n"),
+    unreleasedHeading: lines[unreleasedAt],
+    unreleasedBody: lines.slice(unreleasedAt + 1, tailAt).join("\n").trim(),
+    tail: lines.slice(tailAt).join("\n")
+  };
+};
+var LINK_REF_RE = /^\[(\d+\.\d+\.\d+)\]:\s*(\S*\/tag\/)v\d+\.\d+\.\d+\s*$/;
+var withLinkRef = (tail, version) => {
+  const lines = tail.split("\n");
+  const at = lines.findIndex((line) => LINK_REF_RE.test(line));
+  if (at < 0) return tail;
+  const [, , base] = LINK_REF_RE.exec(lines[at]) ?? [];
+  const ref = `[${version}]: ${base}v${version}`;
+  if (lines.some((line) => line.startsWith(`[${version}]:`))) return tail;
+  return [...lines.slice(0, at), ref, ...lines.slice(at)].join("\n");
+};
+var UNRELEASED_REF_RE = /^(\[Unreleased\]:\s*\S*\/compare\/)v\d+\.\d+\.\d+(\.{3}HEAD)\s*$/i;
+var withUnreleasedRef = (tail, version) => tail.split("\n").map((line) => line.replace(UNRELEASED_REF_RE, `$1v${version}$2`)).join("\n");
+var buildChangelog = ({
+  content,
+  version,
+  date,
+  commits
+}) => {
+  const { head, unreleasedHeading, unreleasedBody, tail } = splitDocument(content);
+  const body = unreleasedBody || renderEntries(commits);
+  if (!body) return null;
+  const released = stripV(version);
+  const blocks = [
+    head.trimEnd(),
+    unreleasedHeading,
+    `## [${released}] - ${date}
+
+${body}`,
+    withUnreleasedRef(withLinkRef(tail.trim(), released), released)
+  ].filter((block) => Boolean(block));
+  return `${blocks.join("\n\n")}
+`;
+};
+var today = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+var updateChangelogFile = async (file, version, commits) => {
+  const content = await readFile(file, "utf8").catch(() => null);
+  if (content === null) return false;
+  const next = buildChangelog({ content, version, date: today(), commits });
+  if (!next || next === content) return false;
+  await writeFile(file, next, "utf8");
+  return true;
+};
+
 // src/release.ts
 import { spawnSync } from "child_process";
+import { existsSync } from "fs";
 import path from "path";
 import { createInterface } from "readline/promises";
 import { stdin, stdout } from "process";
@@ -61,10 +204,10 @@ var getRemoteActionsUrl = () => {
 };
 
 // src/pkg.ts
-import { readFile, writeFile } from "fs/promises";
-var readJson = async (file) => JSON.parse(await readFile(file, "utf8"));
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+var readJson = async (file) => JSON.parse(await readFile2(file, "utf8"));
 var writeJson = async (file, data) => {
-  await writeFile(file, `${JSON.stringify(data, null, 2)}
+  await writeFile2(file, `${JSON.stringify(data, null, 2)}
 `, "utf8");
 };
 var updateVersionFile = async (file, newVersion) => {
@@ -75,39 +218,9 @@ var updateVersionFile = async (file, newVersion) => {
   return true;
 };
 
-// src/semver.ts
-var parseSemver = (tag) => {
-  const match = /^v(\d+)\.(\d+)\.(\d+)(?:-([\w.-]+))?$/.exec(tag);
-  if (!match) return null;
-  const [, major, minor, patch, prerelease] = match;
-  return {
-    major: Number(major),
-    minor: Number(minor),
-    patch: Number(patch),
-    prerelease: prerelease ?? null
-  };
-};
-var applyBump = (v, type) => {
-  if (type === "major") return `v${v.major + 1}.0.0`;
-  if (type === "minor") return `v${v.major}.${v.minor + 1}.0`;
-  return `v${v.major}.${v.minor}.${v.patch + 1}`;
-};
-var determineBump = (commits) => {
-  let bump = "patch";
-  const subjectRe = /^(\w+)(?:\([^)]*\))?(!)?:/;
-  for (const msg of commits) {
-    const subject = msg.split("\n")[0];
-    const match = subjectRe.exec(subject);
-    const breaking = match?.[2] === "!" || /^BREAKING CHANGE:/m.test(msg);
-    if (breaking) return "major";
-    if (match?.[1] === "feat") bump = "minor";
-  }
-  return bump;
-};
-var stripV = (tag) => tag.startsWith("v") ? tag.slice(1) : tag;
-
 // src/release.ts
 var PACKAGE_JSON = path.join(process.cwd(), "package.json");
+var CHANGELOG_MD = path.join(process.cwd(), "CHANGELOG.md");
 var makeRunStep = (dryRun) => (label, cmd, args) => {
   if (dryRun) {
     console.log(`\u2192 [dry-run] ${label}`);
@@ -122,7 +235,8 @@ var release = async (options = {}) => {
     releaseVersion: options.releaseVersion,
     bump: options.bump,
     yes: options.yes ?? false,
-    dryRun: options.dryRun ?? false
+    dryRun: options.dryRun ?? false,
+    changelog: options.changelog ?? true
   };
   ensureCleanTree();
   const branch = ensureOnDefaultBranch();
@@ -187,13 +301,21 @@ var release = async (options = {}) => {
     rl?.close();
     process.exit(1);
   }
+  const writesChangelog = flags.changelog && existsSync(CHANGELOG_MD);
   console.log(`
 This will:`);
   console.log(`  1. Bump package.json   ${pkg.version}  \u2192  ${bareVersion}`);
-  console.log(`  2. Commit on ${branch}`);
-  console.log(`  3. Tag ${normalized} and push ${branch} + tag`);
-  console.log(`  4. GitHub Actions will build, test, and publish to npm
-`);
+  if (writesChangelog) {
+    console.log(`  2. Cut CHANGELOG.md section [${bareVersion}]`);
+  }
+  console.log(`  ${writesChangelog ? 3 : 2}. Commit on ${branch}`);
+  console.log(
+    `  ${writesChangelog ? 4 : 3}. Tag ${normalized} and push ${branch} + tag`
+  );
+  console.log(
+    `  ${writesChangelog ? 5 : 4}. GitHub Actions will build, test, and publish to npm
+`
+  );
   if (flags.dryRun) console.log("Dry-run mode: no changes will be made.\n");
   const confirmed = await askConfirm();
   rl?.close();
@@ -204,12 +326,22 @@ This will:`);
   const runStep = makeRunStep(flags.dryRun);
   if (flags.dryRun) {
     console.log(`\u2192 [dry-run] would bump package.json to ${bareVersion}`);
+    if (writesChangelog) {
+      console.log(`\u2192 [dry-run] would cut CHANGELOG.md section [${bareVersion}]`);
+    }
   } else {
     const pkgChanged = await updateVersionFile(PACKAGE_JSON, bareVersion);
-    if (!pkgChanged) {
-      console.warn("\n\u26A0 package.json already at target version.");
-    } else {
-      runStep(`git add package.json`, "git", ["add", "package.json"]);
+    if (!pkgChanged) console.warn("\n\u26A0 package.json already at target version.");
+    const changelogChanged = writesChangelog && await updateChangelogFile(CHANGELOG_MD, normalized, commitsSinceTag);
+    if (writesChangelog && !changelogChanged) {
+      console.warn("\u26A0 No changelog entries to cut; leaving CHANGELOG.md alone.");
+    }
+    const staged = [
+      pkgChanged ? "package.json" : null,
+      changelogChanged ? "CHANGELOG.md" : null
+    ].filter((file) => file !== null);
+    if (staged.length) {
+      runStep(`git add ${staged.join(" ")}`, "git", ["add", ...staged]);
       runStep(`git commit -m "release: ${normalized}"`, "git", [
         "commit",
         "-m",
@@ -251,5 +383,8 @@ This will:`);
 };
 
 export {
+  parseCommit,
+  renderEntries,
+  buildChangelog,
   release
 };

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   release
-} from "./chunk-67J7X3FS.js";
+} from "./chunk-EBHQERFN.js";
 
 // src/cli.ts
 import { Command, InvalidArgumentError } from "commander";
@@ -20,6 +20,9 @@ var program = new Command().name("doryski-release").description("Bump package.js
   "force the bump level (overrides the auto-detected level; ignored when --release-version is set)",
   parseBump
 ).option("-y, --yes", "skip the confirmation prompt", false).option(
+  "--no-changelog",
+  "skip cutting a CHANGELOG.md section for this release"
+).option(
   "-n, --dry-run",
   "preview the actions without modifying files, committing, tagging, or pushing",
   false
@@ -30,7 +33,8 @@ release({
   releaseVersion: flags.releaseVersion,
   bump: flags.bump,
   yes: flags.yes,
-  dryRun: flags.dryRun
+  dryRun: flags.dryRun,
+  changelog: flags.changelog
 }).catch((err) => {
   console.error(err);
   process.exit(1);

package/dist/index.d.ts

@@ -11,7 +11,25 @@ type ReleaseOptions = {
     bump?: BumpType;
     yes?: boolean;
     dryRun?: boolean;
+    changelog?: boolean;
 };
 declare const release: (options?: ReleaseOptions) => Promise<void>;
 
-export { type BumpType, type ParsedSemver, type ReleaseOptions, release };
+declare const SECTION_ORDER: readonly ["Breaking Changes", "Added", "Changed", "Fixed"];
+type ChangelogSection = (typeof SECTION_ORDER)[number];
+type ChangelogEntry = {
+    section: ChangelogSection;
+    scope: string | null;
+    description: string;
+};
+declare const parseCommit: (message: string) => ChangelogEntry | null;
+declare const renderEntries: (commits: string[]) => string;
+type BuildChangelogInput = {
+    content: string;
+    version: string;
+    date: string;
+    commits: string[];
+};
+declare const buildChangelog: ({ content, version, date, commits, }: BuildChangelogInput) => string | null;
+
+export { type BuildChangelogInput, type BumpType, type ChangelogEntry, type ChangelogSection, type ParsedSemver, type ReleaseOptions, buildChangelog, parseCommit, release, renderEntries };

package/dist/index.js

@@ -1,6 +1,12 @@
 import {
-  release
-} from "./chunk-67J7X3FS.js";
+  buildChangelog,
+  parseCommit,
+  release,
+  renderEntries
+} from "./chunk-EBHQERFN.js";
 export {
-  release
+  buildChangelog,
+  parseCommit,
+  release,
+  renderEntries
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doryski/release",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "A conventional-commit release CLI and reusable GitHub Actions workflow for npm packages",
   "type": "module",
   "main": "./dist/index.js",