@modulify/conventional-release 0.1.0

package/bin/cli.mjs

@@ -0,0 +1,291 @@
+import { GitCommander } from "@modulify/git-toolkit";
+import { Runner } from "@modulify/git-toolkit/shell";
+import { run } from "../dist/index.mjs";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import chalk from "chalk";
+import figures from "figures";
+import * as util from "node:util";
+const DEFAULTS = {
+  dry: false,
+  verbose: false,
+  tags: false
+};
+class CliParseError extends Error {
+  help;
+}
+async function parseArgv(argv = process.argv) {
+  const parser = yargs(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, index) => [slice.id, index + 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.format(template, ...context.map(bold));
+  return `${figure} ${message}`;
+}
+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 GitCommander({ sh: new Runner(cwd) });
+  await run({
+    cwd,
+    dry: options.dry,
+    releaseAs: options.releaseAs,
+    prerelease: options.prerelease,
+    reporter: createReporter({
+      output,
+      git,
+      showTags: options.tags,
+      verbosity: options.verbose ? "detailed" : "summary"
+    })
+  });
+}
+export {
+  main
+};

package/bin/index.cjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+const { main } = require('./cli.cjs')
+
+Promise.resolve(main(process.argv)).catch(() => {
+  process.exit(1)
+})

package/bin/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { main } from './cli.mjs'
+
+try {
+  await main(process.argv)
+} catch {
+  process.exit(1)
+}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+import { Options, RunOptions } from '../types/index';
+type ScopeOptions = Omit<Options, 'changelogFile'>;
+/**
+ * Resolves repository release configuration from `package.json`, `release.config.*`,
+ * and inline overrides using the public precedence rules.
+ */
+export declare function resolveConfig(cwd?: string, inline?: Options): Promise<Options>;
+/** Converts repository configuration to executor-ready release options. */
+export declare function toScopeOptions(config: Options): ScopeOptions;
+/** Extracts inline overrides from high-level run options. */
+export declare function toInlineConfig(options: RunOptions): Options;
+export {};

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_CHANGELOG_FILE = "CHANGELOG.md";
+export declare const DEFAULT_GIT_REMOTE = "origin";
+export declare const DEFAULT_RELEASE_PREFIX = "chore(release): ";
+export declare const DEFAULT_RELEASE_MODE = "sync";
+export declare const DEFAULT_DEPENDENCY_POLICY_INTERNAL = "preserve";
+export declare const RELEASE_CONFIG_FILENAMES: readonly ["release.config.ts", "release.config.mjs", "release.config.js"];

package/dist/execute.d.ts

@@ -0,0 +1,9 @@
+import { Options, Reporter, Result, RunContext } from '../types/index';
+import { DiscoveredScope } from './plan';
+import { Runtime } from './runtime';
+type Reporting = {
+    reporter: Reporter;
+    context: RunContext;
+};
+export declare function runScope(runtime: Runtime, scope: DiscoveredScope, options: Options, reporting?: Reporting): Promise<Result>;
+export {};