cross-release-cli 0.0.1-alpha.5 → 0.1.0-alpha.2

package/README.md

@@ -22,9 +22,9 @@ yarn add cross-release --global
 
 ```json
 {
-  "scripts": {
-    "release": "cross-release"
-  }
+    "scripts": {
+        "release": "cross-release"
+    }
 }
 ```
 
@@ -54,33 +54,33 @@ You can specify various runtime settings by using the "package.json" file. Here
 
 ```json
 {
-  "...": "...",
-  "cross-release": {
+    "...": "...",
+    "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,
-    "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
+        "showHelp": false,
+        // show the version about cross-release
+        "showVersion": false,
+        "version": "",
+        "isAllYes": false,
+        "isDry": false,
+        "isRecursive": false,
+        "shouldCommit": 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.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+"use strict"
+
+const App = await import("../dist/app.js")
+const app = await App.default.create()
+void app.run()

package/dist/app.d.ts

@@ -0,0 +1,29 @@
+import { ProjectFile } from 'cross-bump';
+import { ReleaseOptions } from './types.js';
+
+declare class App {
+    #private;
+    private _currentVersion;
+    private _modifiedFiles;
+    private _nextVersion;
+    private _options;
+    private _projectFiles;
+    private _taskQueue;
+    private _taskStatus;
+    private constructor();
+    static create(argv?: string[]): Promise<App>;
+    checkGitClean(): void;
+    confirmReleaseOptions(): Promise<void>;
+    executeTasks(): Promise<void>;
+    resolveExecutes(): void;
+    resolveNextVersion(): Promise<void>;
+    resolveProjectFiles(): void;
+    resolveProjects(): void;
+    run(): Promise<void>;
+    get currentVersion(): string;
+    get nextVersion(): string;
+    get options(): ReleaseOptions;
+    get projectFiles(): ProjectFile[];
+}
+
+export { App as default };

package/dist/app.js

@@ -0,0 +1,616 @@
+// src/app.ts
+import process4 from "node:process";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  log as log2,
+  outro
+} from "@clack/prompts";
+import {
+  findProjectFiles,
+  getProjectVersion,
+  isVersionValid as isVersionValid2,
+  upgradeProjectVersion
+} from "cross-bump";
+import { execaSync, parseCommandString } from "execa";
+import isUnicodeSupported from "is-unicode-supported";
+import color2 from "picocolors";
+
+// src/cli.ts
+import path from "node:path";
+import { toAbsolute as toAbsolute2 } from "@rainbowatcher/path-extra";
+import { Command } from "commander";
+import { getGitignores } from "cross-bump";
+import { defu as defu2 } from "defu";
+
+// package.json
+var version = "0.1.0-alpha.1";
+
+// src/constants.ts
+import process from "node:process";
+var CONFIG_DEFAULT = {
+  all: false,
+  commit: {
+    stageAll: false,
+    template: "chore: release v%s",
+    verify: true
+  },
+  cwd: process.cwd(),
+  debug: false,
+  dry: false,
+  exclude: ["node_modules", ".git"],
+  execute: [],
+  main: "javascript",
+  push: {
+    followTags: false
+  },
+  recursive: false,
+  tag: {
+    template: "v%s"
+  },
+  yes: false
+};
+
+// src/util/config.ts
+import process2 from "node:process";
+import { isFileSync } from "@rainbowatcher/fs-extra";
+import { toAbsolute } from "@rainbowatcher/path-extra";
+import defu from "defu";
+import { loadConfig } from "unconfig";
+
+// src/util/debug.ts
+import debug from "debug";
+function createDebug(ns) {
+  return debug(`cross-release-cli:${ns}`);
+}
+function isDebugEnable(options) {
+  if (options.debug) {
+    debug.enable("cross-release-cli:*");
+  }
+}
+
+// src/util/config.ts
+var debug2 = createDebug("config");
+function resolveAltOptions(opts, key, defaultValue) {
+  const value = opts[key];
+  const _defaultValue = defaultValue ?? {};
+  return typeof value === "boolean" ? value ? _defaultValue : {} : { ..._defaultValue, ...value };
+}
+async function loadUserSpecifiedConfigFile(configPath, currentOpts) {
+  const absConfigPath = toAbsolute(configPath);
+  if (!isFileSync(absConfigPath)) {
+    throw new Error(`${absConfigPath} is not a valid file.`);
+  }
+  const { config, sources } = await loadConfig({
+    sources: [{
+      files: absConfigPath
+    }]
+  });
+  debug2("load specified config file:", sources);
+  return defu({ config: toAbsolute(currentOpts.config ?? "") }, currentOpts, config);
+}
+async function loadUserConfig(cwd = process2.cwd()) {
+  const { config: userConfig, sources } = await loadConfig({
+    cwd,
+    sources: [
+      { files: "cross-release.config" },
+      {
+        extensions: ["json"],
+        files: "package",
+        rewrite(config) {
+          return config["cross-release"];
+        }
+      }
+    ]
+  });
+  debug2("load user config", sources);
+  debug2("user config:", userConfig);
+  return userConfig;
+}
+
+// src/cli.ts
+var debug3 = createDebug("cli");
+function createCliProgram() {
+  const cli = new Command("cross-release");
+  cli.configureHelp({
+    subcommandTerm: (cmd) => `${cmd.name()} ${cmd.usage()}`
+  });
+  cli.name("cross-release").version(version).description("A release tool that support multi programming language").usage("[version] [options]").option("-a, --all", "Add all changed files to staged", CONFIG_DEFAULT.commit.stageAll).option("-c, --config [file]", "Config file (auto detect by default)").option("-D, --dry", "Dry run", CONFIG_DEFAULT.dry).option("-d, --debug", "Enable debug mode", CONFIG_DEFAULT.debug).option("-e, --exclude [dir]", "Folders to exclude from search", CONFIG_DEFAULT.exclude).option("-m, --main", "Base project language [e.g. java, rust, javascript]", CONFIG_DEFAULT.main).option("-r, --recursive", "Run the command for each project in the workspace", CONFIG_DEFAULT.recursive).option("-x, --execute [command...]", "Execute the command", CONFIG_DEFAULT.execute).option("-y, --yes", "Answer yes to all prompts", CONFIG_DEFAULT.yes).option("--cwd [dir]", "Set working directory", CONFIG_DEFAULT.cwd).option("--no-commit", "Skip committing changes").option("--no-push", "Skip pushing").option("--no-tag", "Skip tagging").option("-h, --help", "Display this message");
+  return cli;
+}
+function toCliReleaseOptions(cli) {
+  const { args } = cli;
+  const options = cli.opts();
+  if (options.help) {
+    cli.help();
+  }
+  return {
+    ...options,
+    ...args.length > 0 ? { version: args[0] } : {}
+  };
+}
+async function resolveOptions(cli) {
+  const cliOptions = toCliReleaseOptions(cli);
+  let userConfig;
+  if (cliOptions.config) {
+    userConfig = await loadUserSpecifiedConfigFile(cliOptions.config, cliOptions);
+  } else {
+    userConfig = await loadUserConfig();
+  }
+  const parsedArgs = defu2(cliOptions, userConfig);
+  isDebugEnable(parsedArgs);
+  const set = getGitignores(parsedArgs.cwd);
+  for (const i of parsedArgs.exclude) set.add(i);
+  parsedArgs.exclude = [...set];
+  const shouldBeAbsolute = ["cwd", "config"];
+  for (const key of shouldBeAbsolute) {
+    if (!parsedArgs[key]) continue;
+    if (key === "cwd") {
+      const { cwd } = parsedArgs;
+      parsedArgs.cwd = toAbsolute2(cwd);
+    }
+    parsedArgs[key] = path.resolve(parsedArgs.cwd, parsedArgs[key]);
+  }
+  debug3("parsedArgs:", parsedArgs);
+  return parsedArgs;
+}
+
+// src/git.ts
+import process3 from "node:process";
+import { log, spinner } from "@clack/prompts";
+import { execaSync as createExeca } from "execa";
+import color from "picocolors";
+var debug4 = createDebug("git");
+var execa = createExeca({ all: true, reject: false });
+function gitTag(options) {
+  const {
+    cwd = process3.cwd(),
+    del = false,
+    dry = false,
+    force = false,
+    message: message2,
+    tagName: name
+  } = options ?? {};
+  const s = spinner();
+  s.start("creating tag...");
+  const args = [];
+  if (del) {
+    args.push("--delete");
+  } else {
+    if (!message2 || message2?.length === 0) {
+      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),
+        message2
+      );
+    }
+  }
+  if (force) args.push("--force");
+  args.push(name);
+  debug4(`command: git tag ${args.join(" ")}`);
+  if (!dry) {
+    const { exitCode, failed, shortMessage, stderr, stdout } = execa("git", ["tag", ...args], { cwd });
+    debug4("git tag stdout:", stdout, stderr);
+    if (failed) {
+      s.stop(color.red(shortMessage), exitCode);
+      return false;
+    }
+  }
+  s.stop(`create git tag: ${color.blue(name)}`);
+  return true;
+}
+function gitCommit(options) {
+  const {
+    cwd = process3.cwd(),
+    dry = false,
+    message: message2,
+    modifiedFiles = [],
+    stageAll,
+    verify
+  } = options ?? {};
+  const s = spinner();
+  s.start("committing...");
+  const args = [];
+  args.push("--message", message2);
+  !verify && args.push("--no-verify");
+  if (!stageAll && modifiedFiles.length > 0) {
+    args.push("--", ...modifiedFiles);
+  } else {
+    args.push("--all");
+  }
+  debug4(`command: git commit ${args.join(" ")}`);
+  if (!dry) {
+    const { exitCode, failed, shortMessage, stderr, stdout } = execa("git", ["commit", ...args], { cwd });
+    debug4("git commit stdout:", stdout, stderr);
+    if (failed) {
+      s.stop(color.red(shortMessage), exitCode);
+      return false;
+    }
+  }
+  s.stop(`commit message: ${color.green(message2)}`);
+  return true;
+}
+function gitPush(options = {}) {
+  const {
+    branch,
+    cwd = process3.cwd(),
+    dry,
+    followTags = true,
+    remote
+  } = options;
+  const s = spinner();
+  s.start("pushing...");
+  const args = [];
+  if (remote) {
+    args.push(remote);
+    if (branch) {
+      args.push(branch);
+    }
+  }
+  followTags && args.push("--follow-tags");
+  debug4(`command: git push ${args.join(" ")}`);
+  if (!dry) {
+    const { exitCode, failed, shortMessage, stderr, stdout } = execa("git", ["push", ...args], { cwd });
+    debug4("git push stdout:", stdout, stderr);
+    if (failed) {
+      s.stop(color.red(shortMessage), exitCode);
+      return false;
+    }
+  }
+  const originUrl = gitOriginUrl();
+  s.stop(`pushed to repo: ${color.underline(originUrl)}`);
+  return true;
+}
+function gitOriginUrl() {
+  const command = execa("git", ["remote", "get-url", "origin"]);
+  return command.stdout.trim();
+}
+function gitAdd(options = {}) {
+  const {
+    all = false,
+    cwd = process3.cwd(),
+    dry = false,
+    files = []
+  } = options;
+  const args = [];
+  if (all) {
+    args.push("-A");
+  } else if (files.length > 0) {
+    args.push("--", ...files);
+  }
+  debug4("command: git add", args.join(" "));
+  if (!dry) {
+    const { failed, stderr, stdout } = execa("git", ["add", ...args], { cwd });
+    debug4("git add stdout:", stdout, stderr);
+    if (failed) {
+      return false;
+    }
+  }
+  debug4("add files:", files);
+  return true;
+}
+function isGitClean(options = {}) {
+  const { cwd = process3.cwd() } = options;
+  const args = ["diff-index", "--quiet", "HEAD", "--"];
+  const { failed, message: message2 } = execa("git", args, { cwd });
+  if (message2?.includes("bad revision")) {
+    return true;
+  }
+  return !failed;
+}
+function getStagedFiles(opts = {}) {
+  const { cwd } = opts;
+  let stagedArr = [];
+  const args = ["--name-only", "--staged", "-z", "--diff-filter=ACMR"];
+  debug4("command: git diff", args.join(" "));
+  const { all, failed } = execa("git", ["diff", ...args], { cwd });
+  if (!failed) {
+    stagedArr = all.replace(/\0$/, "").split("\0");
+  }
+  return stagedArr;
+}
+
+// src/prompt.ts
+import { select, text } from "@clack/prompts";
+import { getNextVersions, isVersionValid, parseVersion } from "cross-bump";
+async function chooseVersion(currentVersion) {
+  const versionObj = parseVersion(currentVersion);
+  const {
+    nextMajor,
+    nextMinor,
+    nextPatch,
+    nextPreMajor,
+    nextPreMinor,
+    nextPrePatch,
+    nextRelease
+  } = getNextVersions(versionObj ?? void 0);
+  const C_CUSTOM = "custom";
+  const versions = [
+    { label: "custom...", value: C_CUSTOM },
+    { label: `next (${nextRelease})`, value: nextRelease },
+    { label: `keep (${currentVersion})`, value: currentVersion ?? "" },
+    { 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 select({
+    initialValue: versions[1].value ?? C_CUSTOM,
+    message: `Pick a project version. (current: ${currentVersion})`,
+    options: versions
+  });
+  if (!selectedValue || selectedValue === C_CUSTOM) {
+    return await text({
+      message: "Input your custom version number",
+      placeholder: "version number",
+      validate: (value) => {
+        if (!isVersionValid(value)) {
+          return "Invalid";
+        }
+      }
+    });
+  } else {
+    return selectedValue;
+  }
+}
+
+// src/util/str.ts
+function formatMessageString(template, nextVersion) {
+  return template?.includes("%s") ? template.replaceAll("%s", nextVersion) : template + nextVersion;
+}
+
+// src/app.ts
+var debug5 = createDebug("app");
+function message(msg) {
+  const bar = isUnicodeSupported() ? "\u2502" : "|";
+  console.log(`${color2.gray(bar)}  ${msg}`);
+}
+function handleUserCancel(result) {
+  if (isCancel(result)) {
+    cancel("User cancel");
+    process4.exit(2 /* Canceled */);
+  }
+  return result;
+}
+var App = class _App {
+  _currentVersion = "";
+  _modifiedFiles = [];
+  _nextVersion = "";
+  _options;
+  _projectFiles = [];
+  _taskQueue = [];
+  _taskStatus = "pending";
+  constructor(opts) {
+    this._options = opts;
+  }
+  static async create(argv = process4.argv) {
+    const cli = createCliProgram().parse(argv);
+    const opts = await resolveOptions(cli);
+    return new _App(opts);
+  }
+  #addTask(task, idx) {
+    const expect = this._taskQueue.length + 1;
+    if (idx) {
+      this._taskQueue.splice(idx, 0, task);
+    } else {
+      this._taskQueue.push(task);
+    }
+    return this._taskQueue.length === expect;
+  }
+  #check(status) {
+    if (Array.isArray(status)) {
+      if (status.some((s) => !s)) {
+        this._taskStatus = "failed";
+      }
+    } else if (!status) {
+      this._taskStatus = "failed";
+    }
+  }
+  #checkDryRun() {
+    if (this._options.dry) {
+      log2.message(color2.bgBlue(" DRY RUN "));
+      process4.env.DRY = "true";
+    }
+  }
+  #done() {
+    if (this._taskStatus === "failed") {
+      outro(color2.red("Error"));
+      process4.exit(1 /* FatalError */);
+    } else {
+      outro("Done");
+      this._taskStatus = "finished";
+    }
+  }
+  #start() {
+    intro("Cross release");
+    this.#checkDryRun();
+    this._taskStatus = "running";
+  }
+  checkGitClean() {
+    const { cwd } = this._options;
+    if (!isGitClean({ cwd })) {
+      log2.warn("git is not clean, please commit or stash your changes before release");
+      this.#done();
+      process4.exit(3 /* GitDirty */);
+    }
+  }
+  async confirmReleaseOptions() {
+    const { all, cwd, dry, yes } = this._options;
+    const confirmTask = async (name, message2, exec) => {
+      if (yes) {
+        if (!this._options[name]) return;
+        this._options[name] = true;
+      } else if (this._options[name]) {
+        const confirmation = await confirm({ message: message2 });
+        this._options[name] = handleUserCancel(confirmation);
+      }
+      if (this._options[name]) {
+        this.#addTask({ exec, name });
+      }
+    };
+    let commitMessage;
+    if (this._options.commit) {
+      const {
+        stageAll,
+        template,
+        verify
+      } = resolveAltOptions(this._options, "commit", {
+        ...CONFIG_DEFAULT.commit,
+        stageAll: all
+      });
+      this.#addTask({
+        exec: () => {
+          return gitAdd({
+            all: stageAll === false ? all : stageAll,
+            cwd,
+            dry,
+            files: this._modifiedFiles
+          });
+        },
+        name: "add"
+      });
+      commitMessage = formatMessageString(template, this._nextVersion);
+      await confirmTask("commit", "should commit?", () => {
+        debug5("staged files: %O", getStagedFiles({ cwd }));
+        return gitCommit({
+          cwd,
+          dry,
+          message: commitMessage,
+          modifiedFiles: this._modifiedFiles,
+          // stageAll,
+          verify
+        });
+      });
+    }
+    if (this._options.tag && commitMessage !== void 0) {
+      const { template: tagTpt } = resolveAltOptions(this._options, "tag", CONFIG_DEFAULT.tag);
+      await confirmTask("tag", "should create tag?", () => {
+        const tagName = formatMessageString(tagTpt, this._nextVersion);
+        return gitTag({
+          cwd,
+          dry,
+          message: commitMessage,
+          tagName
+        });
+      });
+    }
+    if (this._options.push) {
+      const { followTags } = resolveAltOptions(this._options, "push", CONFIG_DEFAULT.push);
+      await confirmTask("push", "should push to remote?", () => {
+        return gitPush({ cwd, dry, followTags });
+      });
+    }
+  }
+  async executeTasks() {
+    debug5("taskQueue:", this._taskQueue);
+    for await (const task of this._taskQueue) {
+      if (this._taskStatus === "failed") break;
+      this.#check(await task.exec());
+    }
+  }
+  resolveExecutes() {
+    const { cwd, execute } = this._options;
+    const indexBeforeCommit = this._taskQueue.findIndex((t) => t.name === "commit") - 1;
+    const index = indexBeforeCommit === -1 ? this._taskQueue.length : indexBeforeCommit;
+    for (const command of execute) {
+      if (!command) continue;
+      const [cmd, ...args] = parseCommandString(command);
+      if (!cmd) continue;
+      const exec = () => {
+        debug5("exec command: %s %s", cmd, args.join(" "));
+        const { exitCode, failed, stdout } = execaSync(cmd, args, { cwd, reject: false });
+        debug5("exec stdout:", stdout, exitCode);
+        if (failed) {
+          log2.error(`exec: ${command}`);
+          return false;
+        } else {
+          log2.success(`exec: ${command}`);
+          return true;
+        }
+      };
+      this.#addTask({ exec, name: "anonymous" }, index);
+    }
+  }
+  async resolveNextVersion() {
+    const { main, version: version2 } = this._options;
+    const mainProjectFile = this._projectFiles.find((file) => file.category === main);
+    if (!mainProjectFile) {
+      throw new Error(`can't found ${main} project file in the project root`);
+    }
+    const projectVersion = await getProjectVersion(mainProjectFile);
+    this._currentVersion = projectVersion ?? "";
+    if (isVersionValid2(version2)) {
+      this._nextVersion = version2;
+      log2.info(`current version: ${this._currentVersion}, next version: ${color2.blue(this._nextVersion)}`);
+    } else {
+      const nextVersion = await chooseVersion(this._currentVersion);
+      this._nextVersion = handleUserCancel(nextVersion);
+    }
+  }
+  resolveProjectFiles() {
+    const { cwd, exclude, recursive } = this._options;
+    const projectFiles = findProjectFiles(cwd, exclude, recursive);
+    if (projectFiles.length === 0) {
+      console.error("can't found any project file in the project root");
+      process4.exit(1);
+    }
+    debug5(`found ${projectFiles.length} project files`);
+    this._projectFiles = projectFiles;
+  }
+  resolveProjects() {
+    const { _nextVersion, _projectFiles } = this;
+    this.#addTask({
+      exec: async () => {
+        return await Promise.all(_projectFiles.map(async (projectFile) => {
+          try {
+            await upgradeProjectVersion(_nextVersion, projectFile);
+            this._modifiedFiles.push(projectFile.path);
+            message(`upgrade to ${color2.blue(_nextVersion)} for ${color2.gray(projectFile.path)}`);
+          } catch (error) {
+            log2.error(String(error));
+            return false;
+          }
+          return true;
+        }));
+      },
+      name: "upgradeVersion"
+    });
+  }
+  async run() {
+    this.#start();
+    this.checkGitClean();
+    this.resolveProjectFiles();
+    await this.resolveNextVersion();
+    this.resolveProjects();
+    await this.confirmReleaseOptions();
+    this.resolveExecutes();
+    await this.executeTasks();
+    this.#done();
+  }
+  get currentVersion() {
+    return this._currentVersion;
+  }
+  get nextVersion() {
+    return this._nextVersion;
+  }
+  get options() {
+    return this._options;
+  }
+  get projectFiles() {
+    return this._projectFiles;
+  }
+};
+var app_default = App;
+export {
+  app_default as default
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { DefineConfigOptions } from './types.js';
+import 'cross-bump';
+
+declare function defineConfig(config: DefineConfigOptions): DefineConfigOptions;
+
+export { defineConfig };

package/dist/index.js

@@ -0,0 +1,7 @@
+// src/index.ts
+function defineConfig(config) {
+  return config;
+}
+export {
+  defineConfig
+};

package/dist/types.d.ts

@@ -0,0 +1,127 @@
+import { ProjectCategory } from 'cross-bump';
+
+type Arrayable<T> = T | T[];
+type CliPrimitive = boolean | string | string[];
+type ExcludeType<T, U> = {
+    [K in keyof T]: T[K] extends U ? T[K] : Exclude<T[K], U>;
+};
+type KeysOf<T, KeyType = string> = keyof {
+    [K in keyof T as T[K] extends KeyType ? K : never]: T[K];
+};
+type ResolvedOptions<T> = T extends boolean ? never : NonNullable<T>;
+type Status = "failed" | "finished" | "pending" | "running";
+type ExtractBooleanKeys<T> = keyof Pick<T, {
+    [K in keyof T]: T[K] extends boolean | Record<string, unknown> ? K : never;
+}[keyof T]>;
+type Task = {
+    exec: () => boolean | boolean[] | Promise<boolean | boolean[]>;
+    name: string;
+};
+type ReleaseOptionsDefault = Omit<ExcludeType<ReleaseOptions, CliPrimitive>, "config" | "version">;
+type DefineConfigOptions = Partial<Omit<ReleaseOptions, "config">>;
+type CliReleaseOptions = ExcludeType<ReleaseOptions, Record<string, unknown>>;
+type ReleaseOptions = {
+    /**
+     * Wethere add all changed files to staged, shorthand for @type {CommitOptions.stageAll}
+     */
+    all: boolean;
+    /**
+     * Indicates whether to commit the changes.
+     * @default false
+     */
+    commit: boolean | CommitOptions;
+    /**
+     * Specifies the path to the configuration file.
+     */
+    config: string;
+    /**
+     * The directory path where the operation will be performed.
+     * @default process.cwd()
+     */
+    cwd: string;
+    /**
+     * Enable debug log
+     */
+    debug: boolean;
+    /**
+     * Whether the operation is being run in a dry-run mode (simulated execution).
+     */
+    dry: boolean;
+    /**
+     * The list of directories to exclude from the search.
+     * @default ["node_modules", ".git"]
+     */
+    exclude: string[];
+    /**
+     * The command to execute before pushing.
+     */
+    execute: string[];
+    /**
+     * Specifies the main project category.
+     */
+    main: ProjectCategory;
+    /**
+     * Whether push changes to remote and push options
+     * @default false
+     */
+    push: boolean | PushOptions;
+    /**
+     * Specifies whether the operation should be performed recursively.
+     * @default false
+     */
+    recursive: boolean;
+    /**
+     * Indicates whether to create a tag for a release.
+     * @default false
+     */
+    tag: boolean | TagOptions;
+    /**
+     * The version string associated with the command or operation.
+     */
+    version: string;
+    /**
+     * Whether all prompts requiring user input will be answered with "yes".
+     * @default false
+     */
+    yes: boolean;
+};
+type CommitOptions = {
+    /**
+     * Whether to stage all files or only modified files.
+     */
+    stageAll?: boolean;
+    /**
+     * The template string for the commit message. if the template contains any "%s" placeholders,
+     * then they are replaced with the version number;
+     */
+    template?: string;
+    /**
+     * Whether to enable git pre-commit and commit-msg hook.
+     * @default true
+     */
+    verify?: boolean;
+};
+type PushOptions = {
+    /**
+     * The branch name
+     */
+    branch?: string;
+    /**
+     * Whether to follow tags
+     */
+    followTags?: boolean;
+    /**
+     * The remote name
+     */
+    remote?: string;
+};
+type TagOptions = {
+    /**
+     * The template for tag name, same as @type {CommitOptions.template}
+     * if the template contains any "%s" placeholders,
+     * then they are replaced with the version number;
+     */
+    template?: string;
+};
+
+export type { Arrayable, CliPrimitive, CliReleaseOptions, CommitOptions, DefineConfigOptions, ExcludeType, ExtractBooleanKeys, KeysOf, PushOptions, ReleaseOptions, ReleaseOptionsDefault, ResolvedOptions, Status, TagOptions, Task };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "cross-release-cli",
-  "version": "0.0.1-alpha.5",
+  "type": "module",
+  "version": "0.1.0-alpha.2",
   "description": "command line app for cross language bump utility",
   "author": {
     "name": "rainbowatcher",
@@ -16,26 +17,29 @@
   "bugs": {
     "url": "https://github.com/rainbowatcher/cross-release/issues"
   },
-  "main": "dist/index.mjs",
+  "main": "dist/index.js",
   "bin": {
     "cross-release": "./bin/cross-release.js"
   },
   "files": [
-    "dist",
-    "bin"
+    "bin",
+    "dist"
   ],
   "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.5"
+    "@rainbowatcher/fs-extra": "^0.2.3",
+    "@rainbowatcher/path-extra": "^0.2.3",
+    "commander": "^12.1.0",
+    "debug": "^4.3.6",
+    "defu": "^6.1.4",
+    "execa": "^9.3.1",
+    "is-unicode-supported": "^2.0.0",
+    "picocolors": "^1.1.0",
+    "unconfig": "^0.5.5",
+    "cross-bump": "0.1.0-alpha.2"
   },
   "scripts": {
     "clean": "rimraf dist/*",
-    "build": "pkgroll"
+    "build": "tsup"
   }
 }

package/bin/cross-release.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-"use strict"
-
-import("../dist/index.mjs")

package/dist/index.mjs

@@ -1,404 +0,0 @@
-import path$1 from 'path';
-import { spinner, log, isCancel, intro, outro, cancel, select, text, confirm } from '@clack/prompts';
-import { findProjectFiles, getProjectVersion, isVersionValid, upgradeProjectVersion, parseVersion, getNextVersions } from 'cross-bump';
-import { red, blue, green, gray, bgBlue } from 'colorette';
-import isUnicodeSupported from 'is-unicode-supported';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import cac from 'cac';
-import { defu } from 'defu';
-import { execa } from 'execa';
-import debug$1 from 'debug';
-
-var version = "0.0.1-alpha.5";
-
-const configDefaults = {
-  showHelp: false,
-  showVersion: false,
-  version: "",
-  isAllYes: false,
-  isDry: false,
-  isRecursive: false,
-  shouldCommit: false,
-  shouldPush: false,
-  shouldTag: false,
-  excludes: ["node_modules", ".git"],
-  dir: process.cwd(),
-  main: "javascript",
-  commit: {
-    shouldVerify: true,
-    shouldStageAll: true,
-    template: "chore: release v%s"
-  },
-  push: {
-    shouldFollowTags: false
-  }
-};
-function loadUserConfig(overrides) {
-  const file = fs.readFileSync(path.resolve(process.cwd(), "package.json"), "utf-8");
-  const userConfig = JSON.parse(file)["cross-release"];
-  return defu(overrides, userConfig, configDefaults);
-}
-function parseOptions() {
-  const cli = cac("cross-release").version(version).usage("[flags] version").option("-r, --recursive", "Run the command for each project in the workspace (default: false)").option("-c, --commit", "Commit current changes (default: false)").option("-d, --dry", "Dry run (default: false)").option("-e, --exclude [dir]", "Folders to exclude from search (default: [node_modules, .git])").option("-m, --main", "Base project language (e.g. java, rust, javascript default: javascript)").option("-D, --dir [dir]", "Set working directory (default: project root)").option("-p, --push", "Push the project to remote (default: false)").option("-t, --tag", "Create a tag for current version (default: false)").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,
-    shouldPush: options.push,
-    shouldTag: options.tag,
-    version: args[0]
-  });
-  return parsedArgs;
-}
-
-function createDebug(ns) {
-  return debug$1(`cross-release-cli:${ns}`);
-}
-
-const debug = createDebug("git");
-async function gitTag(tagName, options) {
-  const s = spinner();
-  s.start("creating tag");
-  const { isForce = false, isDel = false, message } = options || {};
-  const args = [];
-  if (isDel) {
-    args.push("--delete");
-  } else {
-    if (!message || message?.length === 0) {
-      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("git", ["tag", ...args]);
-      debug(`command: ${command}`);
-    } catch (e) {
-      s.stop(red(e.shortMessage));
-      return false;
-    }
-  }
-  s.stop(`create git tag: ${blue(tagName)}`);
-  return true;
-}
-async function gitCommit(message, options) {
-  const s = spinner();
-  s.start("committing");
-  const { modifiedFiles = [], shouldStageAll, shouldVerify } = options || {};
-  const args = [];
-  if (process.env.DRY) {
-    args.push("--dry-run");
-  }
-  args.push("--message", message);
-  if (!shouldStageAll && modifiedFiles.length) {
-    args.push("--", ...modifiedFiles);
-  } else {
-    args.push("--all");
-  }
-  if (!shouldVerify) {
-    args.push("--no-verify");
-  }
-  try {
-    const { command } = await execa("git", ["commit", ...args]);
-    debug(`command: ${command}`);
-    s.stop(`commit message: ${green(message)}`);
-  } catch (e) {
-    s.stop(red(e.shortMessage));
-    return false;
-  }
-  return true;
-}
-async function gitPush(options) {
-  const { shouldFollowTags = true, remote, branch } = options || {};
-  const s = 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 {
-    const { command } = await execa("git", ["push", ...args]);
-    debug(`command: ${command}`);
-    s.stop(`pushed to repo: ${gray(originUrl)}`);
-  } catch (e) {
-    s.stop(red(e.shortMessage));
-    return false;
-  }
-  return true;
-}
-async function gitOriginUrl() {
-  return (await execa("git", ["remote", "get-url", "origin"])).stdout.trim();
-}
-
-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() ? "\u2502" : "|";
-  console.log(`${gray(bar)}  ${msg}`);
-}
-function handleUserCancel() {
-  cancel("User cancel");
-  process.exit(ExitCode.InvalidArgument);
-}
-async function chooseVersion(currentVersion) {
-  const versionObj = parseVersion(currentVersion);
-  const {
-    nextMajor,
-    nextMinor,
-    nextPatch,
-    nextRelease,
-    nextPreMajor,
-    nextPreMinor,
-    nextPrePatch
-  } = getNextVersions(versionObj ?? void 0);
-  const C_CUSTOM = "custom";
-  const versions = [
-    { label: "custom...", value: C_CUSTOM },
-    { label: `next (${nextRelease})`, value: nextRelease },
-    { label: `keep (${currentVersion})`, value: currentVersion || "" },
-    { 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 select({
-    message: `Pick a project version. (current: ${currentVersion})`,
-    options: versions,
-    initialValue: versions[1].value ?? C_CUSTOM
-  });
-  if (!selectedValue || selectedValue === C_CUSTOM) {
-    return await text({
-      message: "Input your custom version number",
-      placeholder: "version number",
-      validate: (value) => {
-        if (!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 = [];
-    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) {
-    log.message(bgBlue(" DRY RUN "));
-    process.env.DRY = "true";
-  }
-};
-_getNextVersion = new WeakSet();
-getNextVersion_fn = async function() {
-  const { dir, excludes, version } = this.options;
-  const projectFiles = await findProjectFiles(dir, excludes);
-  if (!projectFiles.length) {
-    throw new Error("can't found any project file in the project root");
-  }
-  const mainProjectFile = projectFiles.find((file) => file.category === this.options.main);
-  if (!mainProjectFile) {
-    throw new Error(`can't found ${this.options.main} project file in the project root`);
-  }
-  const projectVersion = await getProjectVersion(mainProjectFile);
-  this.currentVersion = projectVersion || "";
-  if (isVersionValid(version)) {
-    this.nextVersion = version;
-  } else {
-    const nextVersion = await chooseVersion(this.currentVersion);
-    if (isCancel(nextVersion)) {
-      handleUserCancel();
-    } else {
-      this.nextVersion = nextVersion;
-    }
-  }
-};
-_getProjects = new WeakSet();
-getProjects_fn = async function() {
-  const { options: { dir, excludes, isRecursive }, nextVersion } = this;
-  const projectFiles = await findProjectFiles(dir, excludes, isRecursive);
-  __privateMethod(this, _addTask, addTask_fn).call(this, {
-    name: "upgradeVersion",
-    exec: () => {
-      return Promise.all(projectFiles.map(async (projectFile) => {
-        try {
-          await upgradeProjectVersion(nextVersion, projectFile);
-          this.modifiedFiles.push(projectFile.path);
-          message(`upgrade to ${blue(nextVersion)} for ${gray(path$1.relative(dir, projectFile.path))}`);
-        } catch (e) {
-          this.taskStatus = "failed";
-          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 confirm({ message: message3 });
-      if (!isCancel(confirmation)) {
-        this.options[optionName] = confirmation;
-      } else {
-        handleUserCancel();
-      }
-    }
-    if (this.options[optionName]) {
-      __privateMethod(this, _addTask, addTask_fn).call(this, {
-        name: taskName,
-        exec: execFn
-      });
-    }
-  };
-  const message2 = this.formatMessageString(commit.template, this.nextVersion);
-  await confirmAndSet(
-    "shouldCommit",
-    "should commit?",
-    "commit",
-    async () => {
-      __privateMethod(this, _check, check_fn).call(this, await gitCommit(message2, {
-        modifiedFiles: this.modifiedFiles,
-        shouldStageAll: commit.shouldStageAll,
-        shouldVerify: commit.shouldVerify
-      }));
-    }
-  );
-  const tagName = `v${this.nextVersion}`;
-  await confirmAndSet(
-    "shouldTag",
-    "should create tag?",
-    "tag",
-    async () => {
-      __privateMethod(this, _check, check_fn).call(this, await gitTag(tagName, { message: message2 }));
-    }
-  );
-  await confirmAndSet(
-    "shouldPush",
-    "should push to remote?",
-    "push",
-    async () => {
-      __privateMethod(this, _check, check_fn).call(this, await gitPush({ shouldFollowTags: this.options.push.shouldFollowTags }));
-    }
-  );
-};
-_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() {
-  intro("Cross release");
-  __privateMethod(this, _checkDryRun, checkDryRun_fn).call(this);
-  this.taskStatus = "running";
-};
-_done = new WeakSet();
-done_fn = function() {
-  outro("Done");
-  this.taskStatus = "finished";
-};
-_check = new WeakSet();
-check_fn = function(status) {
-  if (!status) {
-    this.taskStatus = "failed";
-  }
-};
-var app = new App();
-
-void app.run();