cross-release-cli 0.0.1-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 rainbowatcher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# Cross Release CLI
+
+## Usage
+
+1. install through package manager
+
+```shell
+# pnpm
+pnpm i cross-release -g
+```
+
+otherwise you can use you favorite package manager instead
+
+```shell
+# npm
+npm i cross-release -g
+# yarn
+yarn add cross-release --global
+```
+
+2. add to your package.json
+
+```json
+{
+  "scripts": {
+    "release": "cross-release"
+  }
+}
+```
+
+3. run release script
+
+```shell
+pnpm run release
+```
+
+## Command line
+
+| short | long            | description                                       | default                    |
+| ----- | --------------- | ------------------------------------------------- | -------------------------- |
+| -r    | --recursive     | Run the command for each project in the workspace | `false`                    |
+| -d    | --dry           | Dry run                                           | `false`                    |
+| -D    | --dir [dir]     | Set working directory                             | `project root`             |
+| -p    | --publish       | Publish the project                               | `false`                    |
+| -c    | --commit        | Commit current changes                            | `false`                    |
+| -p    | --push          | Push the project to remote                        | `false`                    |
+| -t    | --tag           | Create a tag for current version                  | `false`                    |
+| -e    | --exclude [dir] | Folders to exclude from search                    | `["node_modules", ".git"]` |
+| -y    | --yes           | Answer yes to all prompts                         | `false`                    |
+
+## Configuration
+
+You can specify various runtime settings by using the "package.json" file. Here are some examples that cover all the parameters:
+
+```json
+{
+  "...": "...",
+  "cross-release": {
+    // show the help message
+    "showHelp": false,
+    // show the version about cross-release
+    "showVersion": false,
+    "version": "",
+    "isAllYes": false,
+    "isDry": false,
+    "isRecursive": false,
+    "shouldCommit": false,
+    "shouldPublish": false,
+    "shouldPush": false,
+    "shouldTag": false,
+    // default exclude folders are `["node_modules", ".git"]`, your config will be append within it
+    "excludes": ["path/to/exclude"],
+    "dir": "/path/to/run",
+    "commit": {
+      // Whether to invoke git pre-commit and commit-msg hook
+      "shouldVerify": true,
+      // Whether to stage all un-staged files or stage only changed files
+      "shouldStageAll": false,
+      // the symbol '%s' will be replace to the version number that you specified
+      "template": "chore: release v%s"
+    },
+    "push": {
+      "shouldFollowTags": false
+    }
+  }
+}
+```

package/bin/cross-release.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+"use strict"
+require("../dist/index.cjs")

package/dist/index.cjs

@@ -0,0 +1,441 @@
+'use strict';
+
+var path$1 = require('path');
+var prompts = require('@clack/prompts');
+var crossBump = require('cross-bump');
+var colorette = require('colorette');
+var isUnicodeSupported = require('is-unicode-supported');
+var path = require('node:path');
+var fs = require('node:fs');
+var cac = require('cac');
+var defu = require('defu');
+var execa = require('execa');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$1);
+var isUnicodeSupported__default = /*#__PURE__*/_interopDefaultLegacy(isUnicodeSupported);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var cac__default = /*#__PURE__*/_interopDefaultLegacy(cac);
+
+var version = "0.0.0";
+
+const configDefaults = {
+  showHelp: false,
+  showVersion: false,
+  version: "",
+  isAllYes: false,
+  isDry: false,
+  isRecursive: false,
+  shouldCommit: false,
+  shouldPublish: false,
+  shouldPush: false,
+  shouldTag: false,
+  excludes: ["node_modules", ".git"],
+  dir: process.cwd(),
+  commit: {
+    shouldVerify: true,
+    shouldStageAll: false,
+    template: "chore: release v%s"
+  },
+  push: {
+    isTagOnly: false
+  }
+};
+function loadUserConfig(overrides) {
+  const file = fs__namespace.readFileSync(path__namespace.resolve(process.cwd(), "package.json"), "utf-8");
+  const userConfig = JSON.parse(file)["cross-release"];
+  return defu.defu(overrides, userConfig, configDefaults);
+}
+function parseOptions() {
+  const cli = cac__default["default"]("cross-release").version(version).usage("[flags] version").option("-r, --recursive", "Run the command for each project in the workspace (default: false)").option("-d, --dry", "Dry run (default: false)").option("-D, --dir <dir>", "Set working directory (default: project root)").option("-p, --publish", "Publish the project (default: false)").option("-c, --commit", "Commit current changes (default: false)").option("-p, --push", "Push the project to remote (default: false)").option("-t, --tag", "Create a tag for current version (default: false)").option("-e, --exclude [dir]", "Folders to exclude from search (default: [node_modules, .git])").option("-y, --yes", "Answer yes to all prompts (default: false)").help().parse();
+  const { args, options } = cli;
+  const parsedArgs = loadUserConfig({
+    dir: options.dir,
+    excludes: options.exclude,
+    isRecursive: options.recursive,
+    isDry: options.dry,
+    isAllYes: options.yes,
+    showHelp: options.help,
+    showVersion: options.version,
+    shouldCommit: options.commit,
+    shouldPublish: options.publish,
+    shouldPush: options.push,
+    shouldTag: options.tag,
+    version: args[0]
+  });
+  return parsedArgs;
+}
+
+async function gitTag(tagName, options) {
+  const s = prompts.spinner();
+  s.start("creating tag");
+  const { isForce = false, isDel = false, message } = options || {};
+  const args = [];
+  if (isDel) {
+    args.push("--delete");
+  } else {
+    if (!message || (message == null ? void 0 : message.length) === 0) {
+      prompts.log.warn("no message provided, is recommended to provide a message for create an annotated tag");
+    } else {
+      args.push(
+        // Create an annotated tag, which is recommended for releases.
+        // See https://git-scm.com/docs/git-tag
+        "--annotate",
+        // Use the same commit message for the tag
+        "--message",
+        // formatMessageString(template, nextVersion),
+        message
+      );
+    }
+  }
+  if (isForce)
+    args.push("--force");
+  args.push(tagName);
+  if (!process.env.DRY) {
+    try {
+      const { command } = await execa.execa("git", ["tag", ...args]);
+      console.log(command);
+    } catch (e) {
+      s.stop(colorette.red(e.shortMessage));
+      return false;
+    }
+  }
+  s.stop(`create git tag: ${colorette.blue(tagName)}`);
+  return true;
+}
+async function gitCommit(message, options) {
+  const s = prompts.spinner();
+  s.start("committing");
+  const { modifiedFiles = [], shouldStageAll = true, shouldVerify = true } = options || {};
+  const args = [];
+  if (process.env.DRY) {
+    args.push("--dry-run");
+  }
+  args.push("--message", `"${message}"`);
+  if (modifiedFiles.length) {
+    await gitAdd(modifiedFiles);
+    args.push(...modifiedFiles);
+  } else if (shouldStageAll) {
+    args.push("--all");
+  }
+  if (!shouldVerify) {
+    args.push("--no-verify");
+  }
+  try {
+    await execa.execa("git", ["commit", ...args]);
+    s.stop(`commit message: ${colorette.green(message)}`);
+  } catch (e) {
+    s.stop(colorette.red(e.shortMessage));
+    return false;
+  }
+  return true;
+}
+async function gitPush(options) {
+  const { shouldFollowTags = true, remote, branch } = options || {};
+  const s = prompts.spinner();
+  s.start("pushing");
+  const originUrl = await gitOriginUrl();
+  const args = [];
+  if (shouldFollowTags) {
+    args.push("--follow-tags");
+  }
+  if (remote) {
+    args.push(remote);
+    if (branch) {
+      args.push(branch);
+    }
+  }
+  if (process.env.DRY) {
+    args.push("--dry-run");
+  }
+  try {
+    await execa.execa("git", ["push", ...args]);
+    s.stop(`pushed to repo: ${colorette.gray(originUrl)}`);
+  } catch (e) {
+    s.stop(colorette.red(e.shortMessage));
+    return false;
+  }
+  return true;
+}
+async function gitOriginUrl() {
+  return (await execa.execa("git", ["remote", "get-url", "origin"])).stdout.trim();
+}
+async function gitAdd(files) {
+  const args = ["-A"];
+  if (process.env.DRY) {
+    args.push("--dry-run");
+  }
+  args.push("--", ...files);
+  try {
+    await execa.execa("git", ["add", ...args]);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+var ExitCode = /* @__PURE__ */ ((ExitCode2) => {
+  ExitCode2[ExitCode2["Success"] = 0] = "Success";
+  ExitCode2[ExitCode2["FatalError"] = 1] = "FatalError";
+  ExitCode2[ExitCode2["InvalidArgument"] = 9] = "InvalidArgument";
+  return ExitCode2;
+})(ExitCode || {});
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _checkDryRun, checkDryRun_fn, _getNextVersion, getNextVersion_fn, _getProjects, getProjects_fn, _confirmReleaseOptions, confirmReleaseOptions_fn, _addTask, addTask_fn, _start, start_fn, _done, done_fn, _check, check_fn;
+function message(msg) {
+  const bar = isUnicodeSupported__default["default"]() ? "\u2502" : "|";
+  console.log(`${colorette.gray(bar)}  ${msg}`);
+}
+function handleUserCancel() {
+  prompts.cancel("User cancel");
+  process.exit(ExitCode.InvalidArgument);
+}
+async function chooseVersion(projectVersion) {
+  var _a;
+  const versionObj = crossBump.parseVersion(projectVersion);
+  const {
+    nextMajor,
+    nextMinor,
+    nextPatch,
+    nextRelease,
+    nextPreMajor,
+    nextPreMinor,
+    nextPrePatch
+  } = crossBump.getNextVersions(versionObj != null ? versionObj : void 0);
+  const C_CUSTOM = "custom";
+  const versions = [
+    { label: "custom...", value: C_CUSTOM },
+    { label: `next (${nextRelease})`, value: nextRelease },
+    { label: `patch (${nextPatch})`, value: nextPatch },
+    { label: `minor (${nextMinor})`, value: nextMinor },
+    { label: `major (${nextMajor})`, value: nextMajor },
+    { label: `pre-patch (${nextPrePatch})`, value: nextPrePatch },
+    { label: `pre-minor (${nextPreMinor})`, value: nextPreMinor },
+    { label: `pre-major (${nextPreMajor})`, value: nextPreMajor }
+  ];
+  const selectedValue = await prompts.select({
+    message: `Pick a project version. (current: ${projectVersion})`,
+    options: versions,
+    initialValue: (_a = versions[1].value) != null ? _a : C_CUSTOM
+  });
+  if (!selectedValue || selectedValue === C_CUSTOM) {
+    return await prompts.text({
+      message: "Input your custom version number",
+      placeholder: "version number",
+      validate: (value) => {
+        if (!crossBump.isVersionValid(value)) {
+          return "Invalid";
+        }
+      }
+    });
+  } else {
+    return selectedValue;
+  }
+}
+class App {
+  constructor() {
+    __privateAdd(this, _checkDryRun);
+    __privateAdd(this, _getNextVersion);
+    __privateAdd(this, _getProjects);
+    __privateAdd(this, _confirmReleaseOptions);
+    __privateAdd(this, _addTask);
+    __privateAdd(this, _start);
+    __privateAdd(this, _done);
+    __privateAdd(this, _check);
+    this.currentVersion = "";
+    this.nextVersion = "";
+    this.modifiedFiles = [];
+    // TODO: record the task execution status to rollback when execution fails
+    this.taskQueue = [];
+    this.taskStatus = "pending";
+    this.options = parseOptions();
+  }
+  async run() {
+    __privateMethod(this, _start, start_fn).call(this);
+    await __privateMethod(this, _getNextVersion, getNextVersion_fn).call(this);
+    await __privateMethod(this, _getProjects, getProjects_fn).call(this);
+    await __privateMethod(this, _confirmReleaseOptions, confirmReleaseOptions_fn).call(this);
+    for await (const task of this.taskQueue) {
+      if (this.taskStatus === "failed") {
+        break;
+      } else {
+        await task.exec();
+      }
+    }
+    __privateMethod(this, _done, done_fn).call(this);
+  }
+  /**
+   * Accepts a message string template (e.g. "release %s" or "This is the %s release").
+   * If the template contains any "%s" placeholders, then they are replaced with the version number;
+   * otherwise, the version number is appended to the string.
+  */
+  formatMessageString(template, nextVersion) {
+    if (template.includes("%s")) {
+      return template.replace(/%s/g, nextVersion);
+    } else {
+      return template + nextVersion;
+    }
+  }
+}
+_checkDryRun = new WeakSet();
+checkDryRun_fn = function() {
+  if (this.options.isDry) {
+    prompts.log.message(colorette.bgBlue(" DRY RUN "));
+    process.env.DRY = "true";
+  }
+};
+_getNextVersion = new WeakSet();
+getNextVersion_fn = async function() {
+  const { dir, excludes, version } = this.options;
+  const projectFile = await crossBump.findProjectFiles(dir, excludes);
+  if (!projectFile.length) {
+    throw new Error("can't found any project file in the project root");
+  }
+  const projectVersion = await crossBump.getProjectVersion(projectFile[0]);
+  this.currentVersion = projectVersion || "";
+  if (crossBump.isVersionValid(version)) {
+    this.nextVersion = version;
+  } else {
+    const nextVersion = await chooseVersion(projectVersion);
+    if (prompts.isCancel(nextVersion)) {
+      handleUserCancel();
+    } else {
+      this.nextVersion = nextVersion;
+    }
+  }
+};
+_getProjects = new WeakSet();
+getProjects_fn = async function() {
+  const { options: { dir, excludes, isRecursive }, nextVersion, currentVersion } = this;
+  const projectFiles = await crossBump.findProjectFiles(dir, excludes, isRecursive);
+  __privateMethod(this, _addTask, addTask_fn).call(this, {
+    name: "upgradeVersion",
+    exec: () => {
+      return Promise.all(projectFiles.map(async (projectFile) => {
+        await crossBump.upgradeProjectVersion(nextVersion, projectFile).then(() => {
+          this.modifiedFiles.push(projectFile.path);
+          message(`upgrade version to ${colorette.blue(nextVersion)} for ${colorette.gray(path__default["default"].relative(dir, projectFile.path))}`);
+        }).catch((e) => {
+          this.taskStatus = "failed";
+          prompts.log.error(String(e));
+        });
+      }));
+    }
+  });
+};
+_confirmReleaseOptions = new WeakSet();
+confirmReleaseOptions_fn = async function() {
+  const { isAllYes, commit } = this.options;
+  const confirmAndSet = async (optionName, message3, taskName, execFn) => {
+    if (isAllYes) {
+      this.options[optionName] = true;
+    } else if (!this.options[optionName]) {
+      const confirmation = await prompts.confirm({ message: message3 });
+      if (!prompts.isCancel(confirmation)) {
+        this.options[optionName] = confirmation;
+      } else {
+        handleUserCancel();
+      }
+    }
+    if (this.options[optionName]) {
+      __privateMethod(this, _addTask, addTask_fn).call(this, {
+        name: taskName,
+        exec: execFn
+        // rollback: rollbackFn,
+      });
+    }
+  };
+  const message2 = this.formatMessageString(commit.template, this.nextVersion);
+  await confirmAndSet(
+    "shouldCommit",
+    "should commit this release?",
+    "commit",
+    async () => {
+      __privateMethod(this, _check, check_fn).call(this, await gitCommit(message2, { modifiedFiles: this.modifiedFiles, shouldStageAll: false }));
+    }
+    // async () => {
+    //   if (!process.env.DRY) {
+    //     await gitReset({ files: this.modifiedFiles })
+    //   }
+    //   log.info("rollback: git reset")
+    // },
+  );
+  const tagName = `v${this.nextVersion}`;
+  await confirmAndSet(
+    "shouldTag",
+    "should create a tag for this release?",
+    "tag",
+    async () => {
+      __privateMethod(this, _check, check_fn).call(this, await gitTag(tagName, { message: message2 }));
+    }
+    // async () => {
+    //   await gitTag(tagName, { isDel: true })
+    //   log.info("rollback: git tag")
+    // },
+  );
+  await confirmAndSet(
+    "shouldPush",
+    "should push to remote repository?",
+    "push",
+    async () => {
+      __privateMethod(this, _check, check_fn).call(this, await gitPush({ shouldFollowTags: this.options.push.isTagOnly }));
+    }
+    // () => undefined,
+  );
+};
+_addTask = new WeakSet();
+addTask_fn = function(task) {
+  const expect = this.taskQueue.length + 1;
+  return this.taskQueue.push(task) === expect;
+};
+_start = new WeakSet();
+start_fn = function() {
+  prompts.intro("Cross release");
+  __privateMethod(this, _checkDryRun, checkDryRun_fn).call(this);
+};
+_done = new WeakSet();
+done_fn = function() {
+  prompts.outro("Done");
+};
+_check = new WeakSet();
+check_fn = function(status) {
+  if (!status) {
+    this.taskStatus = "failed";
+  }
+};
+var app = new App();
+
+void app.run();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "cross-release-cli",
+  "version": "0.0.1-alpha.1",
+  "description": "command line app for cross language bump utility",
+  "author": {
+    "name": "rainbowatcher",
+    "email": "rainbow-w@qq.com",
+    "url": "https://github.com/rainbowatcher"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/rainbowatcher/cross-release/blob/main/packages/cross-release-cli/README.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rainbowatcher/cross-release.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rainbowatcher/cross-release/issues"
+  },
+  "main": "dist/index.cjs",
+  "bin": {
+    "cross-release": "./bin/cross-release.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "cac": "^6.7.14",
+    "colorette": "^2.0.20",
+    "debug": "^4.3.4",
+    "defu": "^6.1.2",
+    "execa": "^8.0.1",
+    "is-unicode-supported": "^1.3.0",
+    "cross-bump": "0.0.1-alpha.1"
+  },
+  "scripts": {
+    "build": "pkgroll"
+  }
+}