@modulify/conventional-release 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,11 @@
 # @modulify/conventional-release
 
-Release orchestration package for conventional workflows.
+Release-core package for conventional workflows.
+
+[![npm version](https://img.shields.io/npm/v/%40modulify%2Fconventional-release?label=npm)](https://www.npmjs.com/package/@modulify/conventional-release)
+[![codecov](https://codecov.io/gh/modulify/conventional/branch/main/graph/badge.svg?flag=conventional-release)](https://codecov.io/gh/modulify/conventional?flags[0]=conventional-release)
+
+[🌐 Translations](https://github.com/modulify/conventional/blob/main/packages/conventional-release/docs/INDEX.md)
 
 This workspace combines:
 - semantic version recommendation from `@modulify/conventional-bump`,
@@ -13,6 +18,22 @@ The package is library-first. It exposes:
 - `run()` to apply the release flow,
 - `conventional-release` as a config-driven CLI binary.
 
+## Scope and non-goals
+
+This package is intentionally focused on release-core responsibilities inside the repository:
+
+- discover the release scope
+- compute versions from commit history
+- update manifests and changelog files
+- finalize the release with a commit and tags
+
+It does not try to be an all-in-one delivery tool.
+In particular, `npm publish`, GitHub Releases, GitLab Releases, registry credentials, and deployment-specific CI steps are out of scope for this package.
+
+The intended layering is:
+- `@modulify/conventional-release` handles planning and repository-local release finalization
+- higher-level tools can add publishing, hosting, or CI-specific orchestration on top
+
 ## Installation
 
 ```bash
@@ -36,6 +57,9 @@ It resolves packages, filters workspaces, detects affected packages, and produce
 2. `run(options)` resolves the same scope and applies side effects.
 It updates manifests, writes the changelog, creates a commit, and creates tags.
 
+That is the end of this package's responsibility boundary.
+Delivery steps outside the repository, such as package publication or hosted release creation, should be implemented above this layer.
+
 `Scope` is the declarative view of a release.
 `Slice` is one execution unit inside that scope.
 
@@ -103,6 +127,7 @@ Useful flags:
 - `--prerelease <channel>`: use `alpha`, `beta`, or `rc`
 
 The CLI reads the same repository configuration as the library API and wires a lifecycle reporter into `run()`.
+It stops after repository-local release finalization and does not publish artifacts.
 
 ## Inspect before running
 
@@ -146,6 +171,23 @@ console.log(result.slices)
 
 When `dry: true` is used, the package still resolves versions, tags, and touched files, but skips write-side effects.
 
+## Pre-1.0 releases
+
+For packages below `1.0.0`, automatic conventional recommendations follow `@modulify/conventional-bump` pre-major semantics by default:
+
+- recommended `major` becomes `minor`
+- recommended `minor` becomes `patch`
+- recommended `patch` stays `patch`
+
+Explicit `releaseAs` overrides stay authoritative, so `releaseAs: 'major'` still produces `1.0.0`.
+Set `preMajor: false` to opt out of automatic downgrades:
+
+```ts
+await run({
+  preMajor: false,
+})
+```
+
 ## Configuration sources
 
 Configuration is resolved in this order:
@@ -198,6 +240,7 @@ The most important public options are:
 
 - `mode`: release strategy, one of `sync`, `async`, or `hybrid`
 - `releaseAs`: explicit semver bump override such as `major`, `minor`, or `patch`
+- `preMajor`: whether automatic recommendations should be downgraded below `1.0.0`
 - `prerelease`: prerelease channel, one of `alpha`, `beta`, or `rc`
 - `fromTag`: explicit lower bound tag for advisory commit analysis
 - `tagPrefix`: tag matcher used during advisory commit analysis

package/bin/cli.cjs

@@ -1,308 +1,32 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const gitToolkit = require("@modulify/git-toolkit");
-const shell = require("@modulify/git-toolkit/shell");
-const index = require("../dist/index.cjs");
-const yargs = require("yargs");
-const helpers = require("yargs/helpers");
-const chalk = require("chalk");
-const figures = require("figures");
-const util = require("node:util");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const util__namespace = /* @__PURE__ */ _interopNamespaceDefault(util);
-const DEFAULTS = {
-  dry: false,
-  verbose: false,
-  tags: false
-};
-class CliParseError extends Error {
-  help;
-}
-async function parseArgv(argv = process.argv) {
-  const parser = yargs(helpers.hideBin(argv)).locale("en").scriptName("conventional-release").usage("Usage: $0 [options]").option("release-as", {
-    alias: "r",
-    describe: "Specify the release type (major|minor|patch)",
-    requiresArg: true,
-    string: true
-  }).option("prerelease", {
-    alias: "p",
-    describe: "Specify the prerelease type (alpha|beta|rc)",
-    requiresArg: true,
-    string: true
-  }).option("dry", {
-    type: "boolean",
-    default: DEFAULTS.dry,
-    describe: "See the commands that running release would run"
-  }).option("verbose", {
-    type: "boolean",
-    default: DEFAULTS.verbose,
-    describe: "Show detailed per-slice progress output"
-  }).option("tags", {
-    type: "boolean",
-    default: DEFAULTS.tags,
-    describe: "Show generated tags in the final output"
-  }).exitProcess(false).check((options) => {
-    if (!["alpha", "beta", "rc", void 0].includes(options.prerelease)) {
-      throw new Error("prerelease should be one of alpha, beta, rc or undefined");
-    }
-    return true;
-  }).showHelpOnFail(false).fail((message) => {
-    throw new Error(message);
-  }).alias("version", "v").alias("help", "h").example("$0", "Update changelog and tag release").example("$0 --dry --verbose", "Show a detailed dry-run release preview").pkgConf("release").wrap(97);
-  let parsed;
-  try {
-    parsed = await parser.parseAsync();
-  } catch (error) {
-    const failure = new CliParseError(error.message);
-    const help = await parser.getHelp();
-    failure.help = [help].flat().join("\n");
-    throw failure;
-  }
-  return {
-    releaseAs: parsed.releaseAs,
-    prerelease: parsed.prerelease,
-    dry: parsed.dry,
-    verbose: parsed.verbose,
-    tags: parsed.tags
-  };
-}
-function createReporter({
-  output,
-  git,
-  showTags = false,
-  verbosity = "summary"
-}) {
-  if (verbosity === "detailed") {
-    return new DetailedReporter({
-      output,
-      git,
-      showTags
-    });
-  }
-  return new SummaryReporter({
-    output,
-    git,
-    showTags
-  });
-}
-class SummaryReporter {
-  output;
-  git;
-  showTags;
-  scope = null;
-  position = /* @__PURE__ */ new Map();
-  constructor({
-    output,
-    git,
-    showTags
-  }) {
-    this.output = output;
-    this.git = git;
-    this.showTags = showTags;
-  }
-  async onStart(context) {
-    this.output.info(
-      context.dry ? "Starting dry release" : "Starting release"
-    );
-  }
-  async onScope(scope, context) {
-    this.scope = scope;
-    this.position = new Map(
-      scope.slices.map((slice, index2) => [slice.id, index2 + 1])
-    );
-  }
-  async onSliceStart(slice) {
-    this.output.info("Running slice %s", [this.describeProgress(slice)]);
-  }
-  async onSuccess(result) {
-    if (!result.changed) {
-      this.output.success("No changes since last release");
-      return;
-    }
-    const changed = result.slices.filter((slice) => slice.changed);
-    const primary = changed[0];
-    const packages = collectPackages(changed);
-    this.output.success("Release slices: %s", [String(changed.length)]);
-    this.output.success("Updated packages: %s", [String(packages.length)]);
-    if (primary) {
-      this.output.success("Next version: %s", [primary.nextVersion]);
-    }
-    if (result.dry) {
-      this.output.info("No committing or tagging since this was a dry run");
-      return;
-    }
-    this.output.success("Committed %s staged files", [String(result.files.length)]);
-    if (this.showTags) {
-      const tags = collectTags(changed);
-      if (tags.length) {
-        this.output.success("Tags: %s", [tags.join(", ")]);
-      }
-    }
-    this.output.info("Run `%s` to publish", [
-      `git push --follow-tags origin ${await this.resolveBranch()}`
-    ]);
-  }
-  async onError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    this.output.error(message);
-  }
-  describeProgress(slice) {
-    const position = this.position.get(slice.id);
-    const total = this.scope?.slices.length;
-    const label = describeSlice(slice);
-    return position && total ? `${position}/${total}: ${label}` : label;
-  }
-  async resolveBranch() {
-    try {
-      return await this.git.revParse("HEAD", { abbrevRef: true });
-    } catch {
-      return "%branch%";
-    }
-  }
-}
-class DetailedReporter extends SummaryReporter {
-  async onScope(scope, context) {
-    await super.onScope(scope, context);
-    this.output.info("%s scope: %s packages, %s affected, %s slices", [
-      scope.mode,
-      String(scope.packages.length),
-      String(scope.affected.length),
-      String(scope.slices.length)
-    ]);
-  }
-  async onSliceSuccess(slice) {
-    if (!slice.changed) {
-      this.output.warn("Completed slice %s without version changes (%s)", [
-        describeSlice(slice),
-        slice.currentVersion
-      ]);
-      return;
-    }
-    this.output.success("Completed slice %s: %s -> %s (%s)", [
-      describeSlice(slice),
-      slice.currentVersion,
-      slice.nextVersion,
-      slice.releaseType
-    ]);
-    if (this.showTags && slice.tag) {
-      this.output.info("Tag: %s", [slice.tag]);
-    }
-  }
-  async onSuccess(result) {
-    await super.onSuccess(result);
-    if (!result.changed) {
-      return;
-    }
-    const packages = collectPackages(result.slices.filter((slice) => slice.changed));
-    this.output.info("Updated packages: %s", [describePackages(packages)]);
-  }
-}
-function describeSlice(slice) {
-  if (slice.partition) {
-    return `${slice.partition} [${describePackages(slice.packages)}]`;
-  }
-  return describePackages(slice.packages);
-}
-function describePackages(packages) {
-  return packages.map((pkg) => pkg.name ?? pkg.path).join(", ");
-}
-function collectTags(slices) {
-  return slices.map((slice) => slice.tag).filter((tag) => !!tag);
-}
-function collectPackages(slices) {
-  const packages = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const slice of slices) {
-    for (const pkg of slice.packages) {
-      const identity = pkg.name ?? pkg.path;
-      if (seen.has(identity)) {
-        continue;
-      }
-      seen.add(identity);
-      packages.push(pkg);
-    }
-  }
-  return packages;
-}
-class ConsoleOutput {
-  write(message) {
-    console.info(message);
-  }
-  writeError(message) {
-    console.error(message);
-  }
-}
-class Output {
-  output;
-  theme;
-  constructor({
-    dry,
-    output = new ConsoleOutput(),
-    theme = createDefaultTheme(dry)
-  }) {
-    this.output = output;
-    this.theme = theme;
-  }
-  info(template, context = [], figure = this.theme.info) {
-    this.output.write(format(template, context, figure));
-  }
-  success(template, context = [], figure = this.theme.success) {
-    this.output.write(format(template, context, figure));
-  }
-  warn(template, context = [], figure = this.theme.warning) {
-    this.output.write(format(template, context, figure));
-  }
-  error(template, context = [], figure = this.theme.error) {
-    this.output.writeError(format(template, context, figure));
-  }
-}
-function createDefaultTheme(dry) {
-  return {
-    success: dry ? chalk.yellow(figures.tick) : chalk.green(figures.tick),
-    warning: chalk.yellow(figures.warning),
-    error: chalk.red(figures.cross),
-    info: chalk.blue(figures.info)
-  };
-}
-function format(template, context, figure) {
-  const bold = (arg) => chalk.bold(arg);
-  const message = util__namespace.format(template, ...context.map(bold));
-  return `${figure} ${message}`;
-}
+require("../dist/_virtual/_rolldown/runtime.cjs");
+const require_index = require("../dist/index.cjs");
+const require_args = require("../dist/cli/args.cjs");
+const require_reporter = require("../dist/cli/reporter.cjs");
+const require_output = require("../dist/cli/output.cjs");
+let _modulify_git_toolkit = require("@modulify/git-toolkit");
+let _modulify_git_toolkit_shell = require("@modulify/git-toolkit/shell");
+//#region src/cli.ts
 async function main(argv = process.argv) {
-  const cwd = process.cwd();
-  const options = await parseArgv(argv);
-  const output = new Output({
-    dry: options.dry,
-    output: new ConsoleOutput()
-  });
-  const git = new gitToolkit.GitCommander({ sh: new shell.Runner(cwd) });
-  await index.run({
-    cwd,
-    dry: options.dry,
-    releaseAs: options.releaseAs,
-    prerelease: options.prerelease,
-    reporter: createReporter({
-      output,
-      git,
-      showTags: options.tags,
-      verbosity: options.verbose ? "detailed" : "summary"
-    })
-  });
-}
+	const cwd = process.cwd();
+	const options = await require_args.parseArgv(argv);
+	const output = new require_output.Output({
+		dry: options.dry,
+		output: new require_output.ConsoleOutput()
+	});
+	const git = new _modulify_git_toolkit.GitCommander({ sh: new _modulify_git_toolkit_shell.Runner(cwd) });
+	await require_index.run({
+		cwd,
+		dry: options.dry,
+		releaseAs: options.releaseAs,
+		prerelease: options.prerelease,
+		reporter: require_reporter.createReporter({
+			output,
+			git,
+			showTags: options.tags,
+			verbosity: options.verbose ? "detailed" : "summary"
+		})
+	});
+}
+//#endregion
 exports.main = main;