@omnitoolkit/releasebot 7.3.1

package/README.md

@@ -0,0 +1,57 @@
+# releasebot
+
+This program analyzes a git repository and, if necessary, performs a release according to the specifications of  [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) and [semantic versioning](https://semver.org/spec/v2.0.0.html).
+
+It uses [semantic-release](https://github.com/semantic-release/semantic-release) (see [documentation](https://semantic-release.gitbook.io/semantic-release)) inside a Docker image with a custom-made module (see [index.js](src/index.js)). There, several plugins along with their configuration are defined and loaded on execution:
+
+- [@semantic-release/commit-analyzer](https://github.com/semantic-release/commit-analyzer) reads each git commit added since the last release, determines if a new release is due, the type of release and the new version number. It analyzes the syntax according to the conventionalcommits preset in [parser.js](https://github.com/conventional-changelog/conventional-changelog/blob/conventional-changelog-conventionalcommits-v9.0.0/packages/conventional-changelog-conventionalcommits/src/parser.js) and checks for custom rules combined from the [default rules list](https://github.com/semantic-release/commit-analyzer/blob/v13.0.1/lib/default-release-rules.js) and the [@commitlint/config-conventional type list](https://github.com/conventional-changelog/commitlint/blob/v19.8.1/%40commitlint/config-conventional/README.md#type-enum). A commit should look like this:
+  ```
+  <type>(<scope>)!: <short summary>
+  │       │      │       │
+  │       │      │       └─> Summary in present tense. Not capitalized. No period at the end.
+  │       │      │
+  │       │      └─> Indicator for breaking change. Optional.
+  │       │
+  │       └─> Commit scope. Can be any string. Optional.
+  │
+  └─> Commit type:    build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test
+      No release:             x
+      Patch release:    x         x   x         x   x      x       x      x    x
+      Minor release:                       x
+      Major release:            (any type when used with '!' indicator)
+  ```
+  (chart from [angular](https://github.com/angular/angular/blob/19.0.0/CONTRIBUTING.md#commit-message-header), changed)
+- [@semantic-release/release-notes-generator](https://github.com/semantic-release/release-notes-generator) generates new release notes from the collected information according to the conventionalcommits preset in [writer.js](https://github.com/conventional-changelog/conventional-changelog/blob/conventional-changelog-conventionalcommits-v9.0.0/packages/conventional-changelog-conventionalcommits/src/writer.js) and the default commit types in [constants.js](https://github.com/conventional-changelog/conventional-changelog/blob/conventional-changelog-conventionalcommits-v9.0.0/packages/conventional-changelog-conventionalcommits/src/constants.js), which are changed to the combined custom rules from above.
+- [@semantic-release/changelog](https://github.com/semantic-release/changelog) updates the changelog file `CHANGELOG.md` with the generated release notes.
+- [@semantic-release/exec](https://github.com/semantic-release/exec) updates the file `VERSION` with the new version number (only if `VERSION` exists) and executes the command `./version.sh X.Y.Z` (only if `version.sh` exists). Both are optional, the latter can be used to set the new version number in other files in the repository.
+- [@semantic-release/git](https://github.com/semantic-release/git) adds a new git commit with the above file changes, places a new git tag (new version number with prefixed `v`) and pushes the changes to the git remote.
+- [@semantic-release/gitlab](https://github.com/semantic-release/gitlab) creates a GitLab release via API with the generated release notes.
+
+## Requirements
+
+- Git repository hosted on GitLab SaaS or self-managed
+- GitLab CI/CD enabled and variable `GITLAB_TOKEN` set (can either be a personal, project or group access token with the scopes `api` and `write_repository`)
+- Willingness of all contributors to follow the commit syntax above
+
+## Usage
+
+- In your `.gitlab-ci.yml`, define the stages explicitly and add a `release` stage at the end of the list. This ensures that the release runs only on a (to this point) successful pipeline.
+  ```yaml
+  stages:
+    - build
+    - test
+    - deploy
+    - release
+  ```
+- Then add the following job and replace `main` with the desired version from the [releases](https://gitlab.com/omnitoolkit/omnitoolkit/-/releases) page:
+  ```yaml
+  release_version:
+    image: registry.gitlab.com/omnitoolkit/omnitoolkit/releasebot:main
+    stage: release
+    rules:
+      - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+    script:
+      - releasebot --branches ${CI_DEFAULT_BRANCH}
+  ```
+- If `CI_DEFAULT_BRANCH` is not your release branch, replace it with the correct one.
+- If you don't want to release on every push to the release branch, add `when: manual` to the job. You can now start the job on demand from the UI.

package/bin/releasebot

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+require("../src/cli.js").main().catch((error) => {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "bin": {
+    "releasebot": "./bin/releasebot"
+  },
+  "dependencies": {
+    "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/exec": "7.1.0",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/gitlab": "13.3.2",
+    "@semantic-release/release-notes-generator": "14.1.0",
+    "conventional-changelog-conventionalcommits": "9.3.1",
+    "semantic-release": "25.0.3"
+  },
+  "description": "Opinionated GitLab semantic-release CLI.",
+  "files": [
+    "bin/releasebot",
+    "src/cli.js",
+    "src/constants.js",
+    "src/index.js"
+  ],
+  "homepage": "https://gitlab.com/omnitoolkit/omnitoolkit/-/tree/main/apps/releasebot#readme",
+  "license": "Apache-2.0",
+  "name": "@omnitoolkit/releasebot",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "apps/releasebot",
+    "type": "git",
+    "url": "git+https://gitlab.com/omnitoolkit/omnitoolkit.git"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "version": "7.3.1"
+}

package/src/cli.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { execFile: execFileCallback, spawn: spawnCallback } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const defaultExecFile = promisify(execFileCallback);
+const defaultConfigPath = path.join(__dirname, "index.js");
+
+function inferGitLabUrl({ env, remoteUrl }) {
+  if (env.CI_SERVER_URL) {
+    return env.CI_SERVER_URL;
+  }
+
+  const sshMatch = remoteUrl.match(/^[^@]+@([^:]+):/);
+
+  if (sshMatch) {
+    return `https://${sshMatch[1]}`;
+  }
+
+  return new URL(remoteUrl).origin;
+}
+
+async function gitOutput(execFile, args) {
+  const result = await execFile("git", args, { encoding: "utf8" });
+  return result.stdout.trim();
+}
+
+async function readGitMetadata(execFile) {
+  const remote = await gitOutput(execFile, ["remote", "get-url", "origin"]);
+  const branch = await gitOutput(execFile, [
+    "rev-parse",
+    "--symbolic-full-name",
+    "--abbrev-ref",
+    "HEAD"
+  ]);
+  const commit = await gitOutput(execFile, ["rev-parse", "--short=8", "HEAD"]);
+
+  if (!remote || !branch || !commit) {
+    throw new Error("missing git metadata");
+  }
+
+  return {
+    branch,
+    commit,
+    remote
+  };
+}
+
+async function fetchGitLabUser({ fetchImpl, gitlabUrl, token }) {
+  const response = await fetchImpl(`${gitlabUrl}/api/v4/user`, {
+    headers: {
+      "PRIVATE-TOKEN": token
+    }
+  });
+  const user = await response.json();
+  const email = user.commit_email || "";
+  const name = user.name || "";
+
+  if (!email || !name) {
+    throw new Error("missing GitLab user identity");
+  }
+
+  return {
+    email,
+    name
+  };
+}
+
+function resolveSemanticReleaseBin() {
+  return require.resolve("semantic-release/bin/semantic-release.js");
+}
+
+function nodePathEnv(existingNodePath) {
+  const paths = module.paths.join(path.delimiter);
+
+  if (!existingNodePath) {
+    return paths;
+  }
+
+  return `${paths}${path.delimiter}${existingNodePath}`;
+}
+
+function indent(text) {
+  return text
+    .trimEnd()
+    .split("\n")
+    .map((line) => `  ${line}`)
+    .join("\n");
+}
+
+function writeStartupSummary({ argv, configText, env, gitMetadata, stdout }) {
+  const extraParameters = argv.length > 0 ? argv.join(" ") : "NONE";
+
+  stdout.write("\n");
+  stdout.write("++++++++++++++++++++++++++++++++++++++++\n");
+  stdout.write("\n");
+  stdout.write("starting sematic-release on git repository\n");
+  stdout.write("\n");
+  stdout.write(`  remote: ${gitMetadata.remote}\n`);
+  stdout.write(`  branch: ${gitMetadata.branch}\n`);
+  stdout.write(`  commit: ${gitMetadata.commit}\n`);
+  stdout.write("\n");
+  stdout.write("with env vars\n");
+  stdout.write("\n");
+  stdout.write("  GITLAB_TOKEN        = [MASKED]\n");
+  stdout.write(`  GITLAB_URL          = ${env.GITLAB_URL}\n`);
+  stdout.write(`  GIT_AUTHOR_EMAIL    = ${env.GIT_AUTHOR_EMAIL}\n`);
+  stdout.write(`  GIT_AUTHOR_NAME     = ${env.GIT_AUTHOR_NAME}\n`);
+  stdout.write(`  GIT_COMMITTER_EMAIL = ${env.GIT_COMMITTER_EMAIL}\n`);
+  stdout.write(`  GIT_COMMITTER_NAME  = ${env.GIT_COMMITTER_NAME}\n`);
+  stdout.write("\n");
+  stdout.write("with config\n");
+  stdout.write("\n");
+  stdout.write(`${indent(configText)}\n`);
+  stdout.write("\n");
+  stdout.write("with extra parameters\n");
+  stdout.write("\n");
+  stdout.write(`${indent(extraParameters)}\n`);
+  stdout.write("\n");
+  stdout.write("++++++++++++++++++++++++++++++++++++++++\n");
+  stdout.write("\n");
+}
+
+function spawnProcess(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawnCallback(command, args, {
+      ...options,
+      stdio: "inherit"
+    });
+
+    child.on("error", reject);
+    child.on("close", (exitCode) => {
+      resolve({ exitCode: exitCode ?? 1 });
+    });
+  });
+}
+
+async function runReleasebot(options = {}) {
+  const argv = options.argv || [];
+  const configPath = options.configPath || defaultConfigPath;
+  const env = options.env || process.env;
+  const execFile = options.execFile || defaultExecFile;
+  const fetchImpl = options.fetch || globalThis.fetch;
+  const readFile = options.readFile || fs.readFile;
+  const spawn = options.spawn || spawnProcess;
+  const stderr = options.stderr || process.stderr;
+  const stdout = options.stdout || process.stdout;
+
+  if (!env.GITLAB_TOKEN) {
+    stderr.write("error - GITLAB_TOKEN not found in env vars\n");
+    return 1;
+  }
+
+  let gitMetadata;
+
+  try {
+    gitMetadata = await readGitMetadata(execFile);
+  } catch (_error) {
+    stderr.write("error - could not interact with git - are you not inside a git repository?\n");
+    return 1;
+  }
+
+  const gitlabUrl = inferGitLabUrl({
+    env,
+    remoteUrl: gitMetadata.remote
+  });
+
+  let gitLabUser;
+
+  try {
+    gitLabUser = await fetchGitLabUser({
+      fetchImpl,
+      gitlabUrl,
+      token: env.GITLAB_TOKEN
+    });
+  } catch (_error) {
+    stderr.write("error - could not get author email and name from gitlab - your GITLAB_TOKEN might be broken\n");
+    return 1;
+  }
+
+  const releaseEnv = {
+    ...env,
+    GITLAB_URL: gitlabUrl,
+    GIT_AUTHOR_EMAIL: gitLabUser.email,
+    GIT_AUTHOR_NAME: gitLabUser.name,
+    GIT_COMMITTER_EMAIL: gitLabUser.email,
+    GIT_COMMITTER_NAME: gitLabUser.name,
+    NODE_PATH: nodePathEnv(env.NODE_PATH)
+  };
+  const configText = await readFile(configPath, "utf8");
+
+  writeStartupSummary({
+    argv,
+    configText,
+    env: releaseEnv,
+    gitMetadata,
+    stdout
+  });
+
+  const result = await spawn(
+    process.execPath,
+    [options.semanticReleaseBin || resolveSemanticReleaseBin(), "--extends", configPath, ...argv],
+    {
+      env: releaseEnv
+    }
+  );
+
+  if (typeof result === "number") {
+    return result;
+  }
+
+  return result.exitCode ?? 1;
+}
+
+async function main() {
+  process.exitCode = await runReleasebot({
+    argv: process.argv.slice(2),
+    env: process.env,
+    stdout: process.stdout,
+    stderr: process.stderr
+  });
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    process.stderr.write(`${error.message}\n`);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  fetchGitLabUser,
+  inferGitLabUrl,
+  main,
+  readGitMetadata,
+  resolveSemanticReleaseBin,
+  runReleasebot
+};

package/src/constants.js

@@ -0,0 +1,48 @@
+// In order to match the custom releaseRules, the file constants.js is replaced.
+export const DEFAULT_COMMIT_TYPES = Object.freeze([
+  {
+    type: 'feat',
+    section: 'Features'
+  },
+  {
+    type: 'fix',
+    section: 'Bug Fixes'
+  },
+  {
+    type: 'perf',
+    section: 'Performance Improvements'
+  },
+  {
+    type: 'revert',
+    section: 'Reverts'
+  },
+  {
+    type: 'docs',
+    section: 'Documentation',
+  },
+  {
+    type: 'style',
+    section: 'Styles',
+  },
+  {
+    type: 'chore',
+    section: 'Miscellaneous Chores',
+    hidden: true
+  },
+  {
+    type: 'refactor',
+    section: 'Code Refactoring',
+  },
+  {
+    type: 'test',
+    section: 'Tests',
+  },
+  {
+    type: 'build',
+    section: 'Build System',
+  },
+  {
+    type: 'ci',
+    section: 'Continuous Integration',
+  }
+].map(Object.freeze))

package/src/index.js

@@ -0,0 +1,64 @@
+module.exports = {
+  branches: [
+    "main"
+  ],
+  ci: false,
+  plugins: [
+    [
+      "@semantic-release/commit-analyzer",
+      {
+        preset: "conventionalcommits",
+        releaseRules: [
+          { breaking: true, release: "major" },
+          { type: "feat", release: "minor" },
+          { revert: true, release: "patch" },
+          { type: "build", release: "patch" },
+          { type: "ci", release: "patch" },
+          { type: "docs", release: "patch" },
+          { type: "fix", release: "patch" },
+          { type: "perf", release: "patch" },
+          { type: "refactor", release: "patch" },
+          { type: "revert", release: "patch" },
+          { type: "style", release: "patch" },
+          { type: "test", release: "patch" },
+          { type: "chore", release: false }
+        ]
+      }
+    ],
+    [
+      // In order to match the custom releaseRules, the file constants.js is replaced.
+      "@semantic-release/release-notes-generator",
+      {
+        preset: "conventionalcommits"
+      }
+    ],
+    [
+      "@semantic-release/changelog",
+      {
+        changelogFile: "CHANGELOG.md"
+      }
+    ],
+    [
+      "@semantic-release/exec",
+      {
+        prepareCmd: "if [ -f VERSION ]; then echo ${nextRelease.version} > VERSION; fi; if [ -x version.sh ]; then ./version.sh ${nextRelease.version}; fi"
+      }
+    ],
+    [
+      "@semantic-release/git",
+      {
+        assets: "**",
+        message: "chore(release): ${nextRelease.version}"
+      }
+    ],
+    [
+      "@semantic-release/gitlab",
+      {
+        failCommentCondition: false,
+        failTitle: false,
+        labels: false,
+        successCommentCondition: false
+      }
+    ]
+  ]
+}