release-suite 0.1.0 → 1.0.0

package/bin/compute-version.js

@@ -1,132 +1,173 @@
-#!/usr/bin/env node
-import { execSync } from "node:child_process";
-import fs from "node:fs";
-
-function run(cmd) {
-  return execSync(cmd, { encoding: "utf8" }).trim();
-}
-
-const isPreview = process.env.PREVIEW_MODE === "true";
-
-function getPackageVersion() {
-  try {
-    const pkg = JSON.parse(fs.readFileSync("package.json", "utf8"));
-    return pkg.version;
-  } catch {
-    return "0.0.0";
-  }
-}
-
-function getLastTag() {
-  try {
-    const tag = run("git describe --tags --abbrev=0");
-    return tag.replace(/^v/, "");
-  } catch {
-    const pkgVersion = getPackageVersion();
-    if (isPreview) {
-      console.log(
-        `⚠ No previous tag found. Using package.json version (${pkgVersion}) as base.`
-      );
-    }
-    return pkgVersion;
-  }
-}
-
-function getCommitsSince(version) {
-  try {
-    // If version came from package.json (no tag), include all commits
-    const hasTag = (() => {
-      try {
-        run("git describe --tags --abbrev=0");
-        return true;
-      } catch {
-        return false;
-      }
-    })();
-
-    const range = hasTag ? `${version}..HEAD` : "HEAD";
-
-    return run(
-      `git log ${range} --pretty=format:%H%x1f%s%x1f%b`
-    )
-      .split("\n")
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-function parseCommitLine(line) {
-  const [hash, subject = "", body = ""] = line.split("\x1f");
-  return { hash, subject, body };
-}
-
-function detectType(subject, body) {
-  const re =
-    /^(:\S+: )?(feat|fix|refactor|docs|chore|style|test|build|perf|ci|raw|cleanup|remove)(\(.+\))?(!)?:/i;
-
-  const m = subject.match(re);
-  const isBreaking =
-    /BREAKING CHANGE/i.test(body) || (m && m[4] === "!");
-
-  if (isBreaking) return "major";
-  if (m) {
-    const t = m[2].toLowerCase();
-    if (t === "feat") return "minor";
-    if (t === "fix") return "patch";
-  }
-  return "none";
-}
-
-function bumpVersion(type, version) {
-  const [major, minor, patch] = version
-    .split(".")
-    .map(n => parseInt(n, 10) || 0);
-
-  if (type === "major") return `${major + 1}.0.0`;
-  if (type === "minor") return `${major}.${minor + 1}.0`;
-  return `${major}.${minor}.${patch + 1}`;
-}
-
-function main() {
-  const baseVersion = getLastTag();
-  const commits = getCommitsSince(baseVersion).map(parseCommitLine);
-
-  if (!commits.length) process.exit(0);
-
-  let bump = null;
-
-  for (const c of commits) {
-    const t = detectType(c.subject, c.body);
-    if (t === "major") {
-      bump = "major";
-      break;
-    }
-    if (t === "minor" && bump !== "major") bump = "minor";
-    if (t === "patch" && !bump) bump = "patch";
-  }
-
-  if (!bump) {
-    if (isPreview) {
-      console.log("Mode: PREVIEW");
-      console.log("Base version:", baseVersion);
-      console.log("Commits analyzed:", commits.length);
-      console.log("No version bump detected.");
-    }
-    process.exit(0);
-  }
-
-  const nextVersion = bumpVersion(bump, baseVersion);
-
-  if (isPreview) {
-    console.log("Mode: PREVIEW");
-    console.log("Base version:", baseVersion);
-    console.log("Commits analyzed:", commits.length);
-    console.log("Highest bump detected:", bump);
-    console.log("Next version:", nextVersion);
-  } else {
-    console.log(nextVersion);
-  }
-}
-
-main();
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { getLastTag, getCommits, parseCommit } from "../lib/git.js";
+import { readPackageVersion } from "../lib/utils.js";
+import { bumpVersion, detectBumpType } from "../lib/versioning.js";
+
+/* ===========================
+ * Core API (Programmatic)
+ * =========================== */
+
+/**
+ * Analyze commits since the last tag (or since package.json version) and compute whether a release
+ * is needed and what the next semantic version should be.
+ *
+ * The function:
+ * - Determines a base version from the latest git tag (if any) or the package.json version.
+ * - Collects commits in the range (lastTag..HEAD or HEAD) and parses them.
+ * - Detects a bump type ('major' | 'minor' | 'patch') from the commits using conventional-commit style rules.
+ * - Returns either a release plan (nextVersion + bump) or a reason why no release is required.
+ *
+ * @param {Object} [options] - Options object.
+ * @param {string} [options.cwd=process.cwd()] - Working directory to run git/package lookups in.
+ *
+ * @returns {{
+ *   hasRelease: boolean,
+ *   // Present when hasRelease === false:
+ *   reason?: 'no-commits' | 'no-bump-detected',
+ *   // Always present:
+ *   baseVersion: string,
+ *   commitsAnalyzed: number,
+ *   // Present when hasRelease === true:
+ *   nextVersion?: string,
+ *   bump?: 'major' | 'minor' | 'patch'
+ * }}
+ *
+ * Examples:
+ * // No commits since last tag
+ * // { hasRelease: false, reason: 'no-commits', baseVersion: '1.2.3', commitsAnalyzed: 0 }
+ *
+ * // Commits analyzed but none imply a version bump
+ * // { hasRelease: false, reason: 'no-bump-detected', baseVersion: '1.2.3', commitsAnalyzed: 5 }
+ *
+ * // Bump detected (e.g. minor)
+ * // { hasRelease: true, baseVersion: '1.2.3', nextVersion: '1.3.0', bump: 'minor', commitsAnalyzed: 4 }
+ *
+ * @throws {Error} If reading package version or git data fails (propagates errors from helper utilities).
+ */
+export function computeVersion({ cwd = process.cwd() } = {}) {
+  const pkgVersion = readPackageVersion(cwd);
+  const lastTag = getLastTag(cwd);
+  const baseVersion = lastTag ?? pkgVersion;
+
+  const range = lastTag ? `${lastTag}..HEAD` : "HEAD";
+  const commits = getCommits(range, cwd).map(parseCommit);
+
+  if (commits.length === 0) {
+    return {
+      hasRelease: false,
+      reason: "no-commits",
+      baseVersion,
+      commitsAnalyzed: 0,
+    };
+  }
+
+  let bump = null;
+
+  for (const commit of commits) {
+    const type = detectBumpType(commit);
+
+    if (type === "major") {
+      bump = "major";
+      break;
+    }
+    if (type === "minor" && bump !== "major") bump = "minor";
+    if (type === "patch" && !bump) bump = "patch";
+  }
+
+  if (!bump) {
+    return {
+      hasRelease: false,
+      reason: "no-bump-detected",
+      baseVersion,
+      commitsAnalyzed: commits.length,
+    };
+  }
+
+  return {
+    hasRelease: true,
+    baseVersion,
+    nextVersion: bumpVersion(baseVersion, bump),
+    bump,
+    commitsAnalyzed: commits.length,
+  };
+}
+
+/* ===========================
+ * CLI
+ * =========================== */
+
+/**
+ * Parses an array of command-line arguments and returns which known flags are present.
+ *
+ * Recognized flags:
+ *  - "--ci"
+ *  - "--json"
+ *  - "--preview"
+ *
+ * @param {string[]} argv - Array of command-line arguments (e.g. process.argv.slice(2)).
+ * @returns {{ci: boolean, json: boolean, preview: boolean}} An object with boolean properties indicating presence of each flag.
+ */
+function parseFlags(argv) {
+  return {
+    ci: argv.includes("--ci"),
+    json: argv.includes("--json"),
+    preview: argv.includes("--preview"),
+  };
+}
+
+/**
+ * Main CLI entrypoint that computes the next release version, prints the result,
+ * and exits the process according to a predetermined contract.
+ *
+ * Behavior:
+ * - Reads CLI flags via parseFlags(process.argv.slice(2)).
+ * - Calls computeVersion() to obtain an object describing the base version,
+ *   whether a release should be generated, the next version, and a reason code.
+ * - If the parsed flags include `json`, writes the full computeVersion result as
+ *   pretty-printed JSON to stdout.
+ * - Otherwise, if a release was generated (`result.hasRelease`), writes
+ *   `result.nextVersion` to stdout.
+ * - If no release was generated, writes an explanatory error to stderr that
+ *   includes `result.reason` and `result.baseVersion`.
+ *
+ * Exit codes (contract):
+ *   0  -> release generated
+ *   10 -> no bump detected
+ *   2  -> no commits
+ *   1  -> unexpected error
+ *
+ * Side effects:
+ * - Prints to stdout/stderr.
+ * - Terminates the Node.js process via process.exit(...) using the codes above.
+ *
+ * @function main
+ * @returns {void} This function does not return; it exits the process.
+ * @see parseFlags
+ * @see computeVersion
+ */
+function main() {
+  const flags = parseFlags(process.argv.slice(2));
+  const result = computeVersion();
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (result.hasRelease) {
+    console.log(result.nextVersion);
+  } else {
+    console.error(
+      `No release generated (${result.reason}). Base version: ${result.baseVersion}`
+    );
+  }
+
+  if (result.hasRelease) process.exit(0);
+  if (result.reason === "no-bump-detected") process.exit(10);
+  if (result.reason === "no-commits") process.exit(2);
+
+  process.exit(1);
+}
+
+const __filename = fileURLToPath(import.meta.url);
+if (process.argv[1] === __filename) {
+  main();
+}

package/bin/create-tag.js

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
 import { execSync } from "node:child_process";
 import fs from "node:fs";
+import { computeVersion } from "./compute-version.js";
 
-function run(cmd, silent = false) {
-  return execSync(cmd, {
-    stdio: silent ? "pipe" : "inherit",
-    encoding: "utf8",
-  }).trim();
+function run(cmd, captureOutput = true) {
+  if (captureOutput) {
+    const output = execSync(cmd, { encoding: "utf8", stdio: "pipe" });
+    return output ? output.trim() : "";
+  } else {
+    execSync(cmd, { stdio: "inherit" });
+  }
+  return "";
 }
 
 const args = process.argv.slice(2);
@@ -18,7 +22,8 @@ let version;
 if (USE_COMPUTED) {
   console.log("🔢 Computing version dynamically...");
   try {
-    version = run("node bin/compute-version.js", true);
+    const obj = computeVersion({ cwd: process.cwd() });
+    version = obj.nextVersion;
   } catch {
     console.error("❌ Failed to compute version.");
     process.exit(1);
@@ -26,7 +31,7 @@ if (USE_COMPUTED) {
 
   if (!version) {
     console.log("ℹ No version bump detected. Skipping tag creation.");
-    process.exit(0);
+    process.exit(10);
   }
 } else {
   console.log("📦 Using version from package.json...");
@@ -40,7 +45,6 @@ if (USE_COMPUTED) {
 }
 
 const tag = version;
-
 console.log(`🔖 Release version: ${tag}`);
 
 // check if tag exists
@@ -52,14 +56,22 @@ try {
   // OK
 }
 
+const tagMessage = `Release ${tag}`;
+
 if (DRY_RUN) {
   console.log("🧪 Dry-run mode enabled.");
-  console.log(`Would create and push tag: ${tag}`);
+  console.log(`Would create annotated tag: ${tag}`);
+  console.log(`Message: "${tagMessage}"`);
   console.log(`VERSION=${tag}`);
-  process.exit(0);
+  process.exit(5);
 }
 
-run(`git tag ${tag}`);
-run(`git push origin ${tag}`);
-
-console.log(`✔ Tag ${tag} created and pushed`);
+try {
+  run(`git tag -a ${tag} -m "${tagMessage}"`, false);
+  run(`git push origin ${tag}`, false);
+  console.log(JSON.stringify({ tag, tagMessage }, null, 2));
+  process.exit(0);
+} catch (err) {
+  console.error("❌ Failed to create or push tag.", err);
+  process.exit(1);
+}