@cmflow/cli 3.2.1 → 3.4.0-alpha.1

package/src/common/run-command.ts

@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import figures from "figures";
+import inquirer from "inquirer";
+import { Listr, type ListrTask } from "listr2";
+
+import type { CmContext, CommandConstructor } from "./types.js";
+import { getConfig } from "./get-config.js";
+import { getReleaseConfig } from "./get-release-config.js";
+
+function createTasksRunner(tasks: ListrTask[], ctx: CmContext): Promise<void> {
+  return new Listr(tasks, {
+    concurrent: false,
+    renderer: !ctx.verbose ? "default" : "verbose"
+  }).run(ctx);
+}
+
+export async function runCommand(
+  klass: CommandConstructor,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  opts: Record<string, any>
+): Promise<void> {
+  try {
+    const config = getConfig();
+
+    let context = {
+      ...getReleaseConfig(),
+      ...config,
+      branch: { name: config.BRANCH_NAME as string },
+      config,
+      logger: console,
+      verbose: opts.verbose as number | undefined
+    } as unknown as CmContext;
+
+    const command = new klass();
+
+    if (command.mapContext) {
+      context = command.mapContext(opts as Record<string, unknown>, context);
+    }
+
+    if (command.prompt) {
+      context = {
+        ...context,
+        ...((await (inquirer as unknown as { prompt: (q: unknown) => Promise<Record<string, unknown>> }).prompt(
+          command.prompt(context)
+        )) as Record<string, unknown>)
+      };
+    }
+
+    command.verifyConditions?.(context);
+
+    const tasks = command.getTasks(context);
+
+    await createTasksRunner(tasks, context);
+
+    command.success?.(context);
+  } catch (er) {
+    console.error(chalk.red(figures.cross + " " + String(er)));
+    if (opts.verbose) {
+      console.error(String((er as Error).stack ?? "").replace(String(er), ""));
+    }
+    process.exit(-1);
+  }
+}
+
+process.on("unhandledRejection", () => {
+  // avoid extra promise rejection when using toObservable
+});

package/src/common/types.ts

@@ -0,0 +1,26 @@
+import type { ListrTask } from "listr2";
+import type { BaseContext, LastRelease, NextRelease } from "semantic-release";
+import type { getConfig } from "./get-config";
+
+export type CmContext<Extended = any> = BaseContext & {
+  config: ReturnType<typeof getConfig>;
+  branch: { name: string; type?: string };
+  nextRelease?: Partial<NextRelease>;
+  lastRelease?: Partial<LastRelease>;
+  verbose?: number;
+  output?: string[];
+} & Extended;
+
+export type SemanticContext = CmContext;
+
+export interface ICommand {
+  mapContext?(opts: Record<string, unknown>, context: CmContext): CmContext;
+  prompt?(context: CmContext): Array<Record<string, unknown>>;
+  verifyConditions?(context: CmContext): void;
+  getTasks(context: CmContext): ListrTask[];
+  success?(context: CmContext): void;
+}
+
+export type CommandConstructor = new () => ICommand;
+
+export type { ListrTask };

package/src/common/vendor.d.ts

@@ -0,0 +1,4 @@
+// Minimal @semantic-release/commit-analyzer type declarations
+declare module "@semantic-release/commit-analyzer" {
+  export function analyzeCommits(pluginConfig: unknown, context: unknown): Promise<string | null>;
+}

package/src/{index.js → index.ts}

@@ -1,4 +1,8 @@
-import * as commands from "./commands/index.js";
+import * as commands from "./commands";
+
+declare global {
+  const __VERSION__: string;
+}
 
 export * from "./commands/release.js";
 export * from "./common/index.js";

package/src/semantic/core/{analyze-commits.js → analyze-commits.ts}

@@ -1,17 +1,21 @@
 import * as commitAnalyzerPlugins from "@semantic-release/commit-analyzer";
+import type { ReleaseType } from "semantic-release";
+import type { SemanticContext } from "../../common/types.js";
 
 import { calculateSnapshotVersion } from "../utils/calculate-snapshot-version.js";
 
-export async function analyzeCommits(pluginConfig, context) {
+export async function analyzeCommits(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   if (context.branch && context.branch.type !== "prerelease") {
     return commitAnalyzerPlugins.analyzeCommits(pluginConfig, context);
   }
 
   const analyzedCommits = await commitAnalyzerPlugins.analyzeCommits(pluginConfig, context);
   context.nextRelease = context.nextRelease || {};
-  context.nextRelease.type = analyzedCommits;
+  context.nextRelease.type = (analyzedCommits ?? undefined) as ReleaseType;
   context.nextRelease.version = calculateSnapshotVersion(context);
-  context.lastRelease.version = null;
+  if (context.lastRelease) {
+    (context.lastRelease as { version: string | null }).version = null;
+  }
 
   return "patch";
 }

package/src/semantic/core/{conditional.js → conditional.ts}

@@ -1,26 +1,33 @@
 import { getConfig } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export function prepare(pluginConfig, context) {
+interface ConditionalPluginConfig {
+  when?: (context: SemanticContext) => boolean;
+  run?: string | string[];
+  [key: string]: unknown;
+}
+
+export function prepare(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("prepare", pluginConfig, context, context.branch?.type === "release");
 }
 
-export function success(pluginConfig, context) {
+export function success(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("success", pluginConfig, context, context.branch?.type === "release");
 }
 
-export function publish(pluginConfig, context) {
+export function publish(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("publish", pluginConfig, context, context.branch?.type === "release");
 }
 
-export function generateNotes(pluginConfig, context) {
+export function generateNotes(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("generateNotes", pluginConfig, context, context.branch?.type === "release");
 }
 
-export function fail(pluginConfig, context) {
+export function fail(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("fail", pluginConfig, context, context.branch?.type === "release");
 }
 
-async function runAll(step, pluginConfig, context, defaultCondition) {
+async function runAll(step: string, pluginConfig: ConditionalPluginConfig, context: SemanticContext, defaultCondition: boolean) {
   context.config = getConfig();
 
   const condition = pluginConfig.when !== undefined ? pluginConfig.when(context) : defaultCondition;
@@ -31,15 +38,15 @@ async function runAll(step, pluginConfig, context, defaultCondition) {
   }
 
   if (pluginConfig.run) {
-    const tasks = [].concat(pluginConfig.run);
+    const tasks: string[] = ([] as string[]).concat(pluginConfig.run as string);
 
     for (const task of tasks) {
       if (typeof task === "string") {
-        const mod = await import(task);
+        const mod = (await import(task)) as Record<string, (config: unknown, ctx: unknown) => Promise<void>>;
         const taskFunction = mod[step];
 
         if (taskFunction) {
-          context.logger.log(`   Start conditional step "${step}" of plugin "${task}"`);
+          context.logger.info(`   Start conditional step "${step}" of plugin "${task}"`);
 
           try {
             await taskFunction(pluginConfig, context);

package/src/semantic/core/{exit.js → exit.ts}

@@ -1,8 +1,9 @@
 import { getConfig } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export default async function exit(pluginConfig, context) {
+export default async function exit(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   context.config = getConfig();
-  const condition = pluginConfig.when !== undefined ? pluginConfig.when(context) : true;
+  const condition = pluginConfig.when !== undefined ? (pluginConfig.when as (ctx: SemanticContext) => boolean)(context) : true;
 
   if (condition) {
     // avoid next semantic-release steps when is a prerelease or release branch with SKIP_GITHUB_PUBLISH

package/src/semantic/core/prepare/{bump-version.js → bump-version.ts}

@@ -1,36 +1,39 @@
 import { getConfig, getPackageManager, lerna } from "../../../common/index.js";
 import { bumpPackagesVersion } from "../../utils/bump-packages-version.js";
+import type { SemanticContext } from "../../../common/types.js";
 
-export async function prepare(_, context) {
+export async function prepare(_: unknown, context: SemanticContext) {
   context.config = getConfig();
   const {
     config: { PACKAGE_MANAGER, HAS_LERNA, BUMP_METHOD, WORKSPACES },
     logger
   } = context;
-  const versionPackageManager = PACKAGE_MANAGER === "yarn" ? "npm" : PACKAGE_MANAGER;
+  const versionPackageManager = PACKAGE_MANAGER === "yarn" ? "npm" : (PACKAGE_MANAGER as string);
 
   logger.info(`Start bump version for all packages using method: ${BUMP_METHOD}`);
 
+  const version = context.nextRelease?.version ?? "";
+
   switch (BUMP_METHOD) {
     case "native":
       logger.info("Using package manager");
-      getPackageManager(PACKAGE_MANAGER).newVersion(context.nextRelease.version);
+      getPackageManager(PACKAGE_MANAGER as string).newVersion(version);
       break;
     case "lerna":
       if (HAS_LERNA) {
-        await lerna.newVersion(context.nextRelease.version);
+        await lerna.newVersion(version);
       }
       break;
     case "cmflow":
-      await bumpPackagesVersion(context.nextRelease.version, WORKSPACES);
-      await getPackageManager(PACKAGE_MANAGER).install();
+      await bumpPackagesVersion(version, WORKSPACES as string[]);
+      await getPackageManager(PACKAGE_MANAGER as string).install();
       break;
     case "native:lerna":
     default:
-      getPackageManager(versionPackageManager).newVersion(context.nextRelease.version);
+      getPackageManager(versionPackageManager).newVersion(version);
 
       if (HAS_LERNA) {
-        await lerna.newVersion(context.nextRelease.version);
+        await lerna.newVersion(version);
       }
   }
 

package/src/semantic/core/prepare/{commit.js → commit.ts}

@@ -1,6 +1,7 @@
 import { configureGitWorkspace, getConfig, git } from "../../../common/index.js";
+import type { SemanticContext } from "../../../common/types.js";
 
-export async function prepare(pluginConfig, context) {
+export async function prepare(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   context.config = getConfig();
 
   const {
@@ -18,7 +19,7 @@ export async function prepare(pluginConfig, context) {
   logger.info("Get commit stage status");
   git.status();
 
-  const revisionMessage = `chore: ${CI_NAME} build ${context.branch.name} ${BUILD_NUMBER} ${context.nextRelease.gitTag} [ci skip]`;
+  const revisionMessage = `chore: ${CI_NAME} build ${context.branch.name} ${BUILD_NUMBER} ${context.nextRelease?.gitTag} [ci skip]`;
 
   logger.info("Commit changes with revision message: ");
   logger.info(revisionMessage);

package/src/semantic/core/prepare/release-info.ts

@@ -0,0 +1,6 @@
+import { writeFile } from "node:fs/promises";
+import type { SemanticContext } from "../../../common/types.js";
+
+export function prepare(pluginConfig: { path: string }, context: SemanticContext) {
+  return writeFile(pluginConfig.path, context.branch.name, { encoding: "utf-8" });
+}

package/src/semantic/core/{run.js → run.ts}

@@ -1,18 +1,19 @@
 import { getConfig, getPackageManager } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
 
 /**
  * @param pluginConfig {{command: string}}
  * @param context
  * @return {Promise<void>}
  */
-export default async function runCommand(pluginConfig, context) {
+export default async function runCommand(pluginConfig: { command: string }, context: SemanticContext) {
   context.config = getConfig();
   const {
     config: { PACKAGE_MANAGER },
     logger
   } = context;
 
-  const pkgManager = getPackageManager(PACKAGE_MANAGER);
+  const pkgManager = getPackageManager(PACKAGE_MANAGER as string);
 
   logger.info(`Start ${pluginConfig.command} task`);
 

package/src/semantic/core/sync-repository.ts

@@ -0,0 +1,55 @@
+import { getConfig, git } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export default async function syncRepository(pluginConfig: Record<string, unknown>, context: SemanticContext) {
+  context.config = getConfig();
+
+  const {
+    logger,
+    config: { PRODUCTION_BRANCH, ORIGIN, DEVELOP_BRANCH }
+  } = context;
+
+  logger.info("Prepare release");
+
+  async function asyncCatchError(fn: () => unknown) {
+    try {
+      return await fn();
+    } catch (er) {
+      context.logger.error(String(er), (er as Error).stack);
+    }
+  }
+
+  await asyncCatchError(() => git.fetch());
+
+  const branchesOption = context.options?.branches;
+  const branchesArray = Array.isArray(branchesOption) ? branchesOption : branchesOption ? [branchesOption] : [];
+  const candidateBranches =
+    (pluginConfig.includes as string[] | undefined) ||
+    branchesArray.map((branch: string | { name?: string }) => {
+      return (branch as { name?: string }).name || (branch as string);
+    });
+
+  logger.info(`Candidate branches to sync: ${(candidateBranches as string[]).join(", ")}`);
+
+  if ((candidateBranches as string[]).includes(context.branch.name)) {
+    logger.info(`Push ${context.branch.name}`);
+
+    await asyncCatchError(() => {
+      logger.info(`git push --quiet --set-upstream ${ORIGIN} ${context.branch.name}`);
+
+      return git.push("--quiet", "--set-upstream", ORIGIN as string, context.branch.name);
+    });
+  } else {
+    logger.info(`Skip push for ${context.branch.name}`);
+  }
+
+  if (PRODUCTION_BRANCH !== DEVELOP_BRANCH) {
+    logger.info(`Sync ${DEVELOP_BRANCH} with ${PRODUCTION_BRANCH}`);
+    logger.info(`git push -f ${ORIGIN} ${PRODUCTION_BRANCH}:refs/heads/${DEVELOP_BRANCH}`);
+
+    await asyncCatchError(async () => {
+      await git.push("-f", ORIGIN as string, `${PRODUCTION_BRANCH}:refs/heads/${DEVELOP_BRANCH}`);
+      logger.success(`${ORIGIN}/${DEVELOP_BRANCH} branch correctly updated`);
+    });
+  }
+}

package/src/semantic/core/{verify-conditions.js → verify-conditions.ts}

@@ -1,8 +1,9 @@
 import chalk from "chalk";
 
 import { getConfig, git } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export function verifyConditions(pluginConfig, context) {
+export function verifyConditions(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   if (pluginConfig.dryRun) {
     return;
   }
@@ -16,8 +17,8 @@ export function verifyConditions(pluginConfig, context) {
   if (USER && EMAIL) {
     context.logger.info("Configure git with username");
 
-    git.config("--global", "user.name", USER);
-    git.config("--global", "user.email", EMAIL);
+    git.config("--global", "user.name", USER as string);
+    git.config("--global", "user.email", EMAIL as string);
 
     context.logger.info("Configure git branch");
     context.logger.success("Workspace is correctly configured");

package/src/semantic/core/{verify-release.js → verify-release.ts}

@@ -1,8 +1,9 @@
 import { getConfig } from "../../common/index.js";
 import { displayPackageInfo } from "../utils/display-package-info.js";
 import { displayReleaseInfo } from "../utils/display-release-info.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export function verifyRelease(pluginConfig, context) {
+export function verifyRelease(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   context.config = getConfig();
   displayPackageInfo(context);
   displayReleaseInfo(context);

package/src/semantic/docker/publish.ts

@@ -0,0 +1,6 @@
+import { dockerPublish } from "../utils/docker-publish.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export async function publish(pluginConfig: Record<string, unknown>, context: SemanticContext) {
+  await dockerPublish(context);
+}

package/src/semantic/docker/{success.js → success.ts}

@@ -1,6 +1,7 @@
+import type { CmContext } from "../../common/types.js";
 import { dockerCleanTags } from "../utils/docker-clean-tags.js";
 
-export async function success(pluginConfig, context) {
+export async function success(_: Record<string, unknown>, context: CmContext) {
   try {
     await dockerCleanTags(context);
   } catch (er) {

package/src/semantic/utils/__mock__/test1/package.json

@@ -1 +1,7 @@
-{"name":"@package/root","version":"1.1.0","dependencies":{},"devDependencies":{},"peerDependencies":{}}
+{
+  "name": "@package/root",
+  "version": "1.1.0",
+  "dependencies": {},
+  "devDependencies": {},
+  "peerDependencies": {}
+}

package/src/semantic/utils/__mock__/test1/packages/a/package.json

@@ -1 +1,9 @@
-{"name":"@package/a","version":"1.1.0","dependencies":{"@package/b":"1.1.0"},"devDependencies":{},"peerDependencies":{}}
+{
+  "name": "@package/a",
+  "version": "1.1.0",
+  "dependencies": {
+    "@package/b": "1.1.0"
+  },
+  "devDependencies": {},
+  "peerDependencies": {}
+}

package/src/semantic/utils/__mock__/test1/packages/b/package.json

@@ -1 +1,7 @@
-{"name":"@package/b","version":"1.1.0","dependencies":{},"devDependencies":{},"peerDependencies":{}}
+{
+  "name": "@package/b",
+  "version": "1.1.0",
+  "dependencies": {},
+  "devDependencies": {},
+  "peerDependencies": {}
+}

package/src/semantic/utils/{bump-packages-version.test.js → bump-packages-version.test.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import fs from "fs-extra";
 import path from "path";
 import * as url from "url";

package/src/semantic/utils/{bump-packages-version.js → bump-packages-version.ts}

@@ -1,10 +1,10 @@
 import fs from "fs-extra";
-import globby from "globby";
+import { globby } from "globby";
 import { dirname } from "path";
 
 const PACKAGE_JSON_PROPS = ["dependencies", "devDependencies", "peerDependencies"];
 
-export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd()) {
+export async function bumpPackagesVersion(version: string, workspaces: string[], cwd = process.cwd()) {
   const patterns = workspaces.map((path) => `${path}/package.json`).concat("package.json");
 
   const files = await globby(patterns, {
@@ -12,13 +12,13 @@ export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd
     absolute: true
   });
 
-  const names = new Set();
+  const names = new Set<string>();
 
   const packages = await Promise.all(
-    files.map(async (file) => {
-      const pkg = await fs.readJson(file);
+    files.map(async (file: string) => {
+      const pkg = (await fs.readJson(file)) as Record<string, unknown>;
 
-      names.add(pkg.name);
+      names.add(pkg.name as string);
 
       return {
         file,
@@ -28,7 +28,7 @@ export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd
   );
 
   return Promise.all(
-    packages.map(({ pkg, file }) => {
+    packages.map(({ pkg, file }: { pkg: Record<string, unknown>; file: string }) => {
       pkg.version = version;
 
       PACKAGE_JSON_PROPS.forEach((key) => bumpDependencies(pkg, key, version, names));
@@ -39,13 +39,14 @@ export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd
   );
 }
 
-function bumpDependencies(pkg, key, version, names) {
+function bumpDependencies(pkg: Record<string, unknown>, key: string, version: string, names: Set<string>) {
   pkg[key] = pkg[key] || {};
 
-  if (pkg[key]) {
+  const deps = pkg[key] as Record<string, string>;
+  if (deps) {
     names.forEach((name) => {
-      if (pkg[key][name] && !pkg[key][name].startsWith("workspace:")) {
-        pkg[key][name] = version;
+      if (deps[name] && !deps[name].startsWith("workspace:")) {
+        deps[name] = version;
       }
     });
   }

package/src/semantic/utils/{calculate-snapshot-version.test.js → calculate-snapshot-version.test.ts}

@@ -1,3 +1,7 @@
+import { git, getConfig } from "../../common/index.js";
+import type { CmContext } from "../../common/types";
+import { calculateSnapshotVersion } from "./calculate-snapshot-version.js";
+
 vi.mock("../../common/index.js", () => {
   return {
     git: {
@@ -6,19 +10,17 @@ vi.mock("../../common/index.js", () => {
     getConfig: vi.fn()
   };
 });
-const { git, getConfig } = await import("../../common/index.js");
-const { calculateSnapshotVersion } = await import("./calculate-snapshot-version.js");
 
 describe("calculateSnapshotVersion", () => {
   beforeEach(() => {
-    git.getCommitTag.mockReturnValue("13246u");
-    getConfig.mockReturnValue({
+    vi.mocked(git.getCommitTag).mockReturnValue("13246u");
+    vi.mocked(getConfig).mockReturnValue({
       DEPLOY_ON_DOCKER: true,
       PRODUCTION_BRANCH: "production",
       DOCKER_REPOSITORY: "owner",
       DOCKER_HUB_ID: "login",
       DOCKER_HUB_PWD: "password"
-    });
+    } as unknown as CmContext["config"]);
   });
   it("should return the snapshot version", () => {
     const context = {
@@ -26,7 +28,7 @@ describe("calculateSnapshotVersion", () => {
       lastRelease: {
         version: "1.0.0"
       }
-    };
+    } as CmContext;
 
     const version = calculateSnapshotVersion(context);
     expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);
@@ -42,7 +44,7 @@ describe("calculateSnapshotVersion", () => {
       config: {
         REF_COMMIT: "REF_COMMIT"
       }
-    };
+    } as CmContext;
 
     const version = calculateSnapshotVersion(context);
     expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);
@@ -58,7 +60,7 @@ describe("calculateSnapshotVersion", () => {
       config: {
         REF_COMMIT: "REF_COMMIT"
       }
-    };
+    } as CmContext;
 
     const version = calculateSnapshotVersion(context);
     expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);

package/src/semantic/utils/calculate-snapshot-version.ts

@@ -0,0 +1,17 @@
+import semver from "semver";
+
+import { getConfig, git } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export function calculateSnapshotVersion(context: SemanticContext) {
+  context.config = getConfig();
+  const {
+    nextRelease,
+    lastRelease,
+    config: { REF_COMMIT }
+  } = context;
+  const parsed = semver.parse(lastRelease?.version ?? "0.0.0");
+  const { major, minor, patch } = parsed ?? { major: 0, minor: 0, patch: 0 };
+
+  return `${semver.inc(`${major}.${minor}.${patch}`, nextRelease?.type ?? "patch") ?? "0.0.0"}-beta${git.getCommitTag(REF_COMMIT as string)}`;
+}

package/src/semantic/utils/display-package-info.ts

@@ -0,0 +1,12 @@
+import { logSection } from "./log-section.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export function displayPackageInfo(context: SemanticContext) {
+  logSection("Package Info", context);
+  context.logger.info("Name       : " + context.config.PROJECT_NAME);
+  context.logger.info("Version    : " + context.lastRelease?.version);
+  context.logger.info("Repository : " + context.config.REPOSITORY_URL);
+  context.logger.info("Branch     : " + context.branch.name);
+  context.logger.info("Tag        : " + context.lastRelease?.gitTag);
+  context.logger.info("GitHead    : " + context.lastRelease?.gitHead);
+}

package/src/semantic/utils/display-release-info.ts

@@ -0,0 +1,13 @@
+import { logSection } from "./log-section.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export function displayReleaseInfo(context: SemanticContext) {
+  logSection("Release Info", context);
+  context.logger.info("Branch   : " + context.branch.name);
+  context.logger.info("Build N° : " + context.config.BUILD_NUMBER);
+  context.logger.info("Version  : " + context.nextRelease?.version);
+  context.logger.info("Tag      : " + context.nextRelease?.gitTag);
+  context.logger.info("GitHead  : " + context.nextRelease?.gitHead);
+  context.logger.info("Type     : " + context.nextRelease?.type);
+  context.logger.info("Channel  : " + context.nextRelease?.channel);
+}

package/src/semantic/utils/{docker-clean-tags.test.js → docker-clean-tags.test.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 vi.mock("../../common", () => {
   return {
     docker: {

package/src/semantic/utils/{docker-clean-tags.js → docker-clean-tags.ts}

@@ -1,7 +1,14 @@
 import { docker } from "../../common/index.js";
+import type { CmContext } from "../../common/types";
 
-function mapTags(tags) {
-  tags = tags
+interface DockerTag {
+  name: string;
+  last_updated: string | Date;
+  date?: number;
+}
+
+function mapTags(tags: DockerTag[]) {
+  const mapped = tags
     .map((tag) => {
       return {
         name: tag.name,
@@ -12,7 +19,7 @@ function mapTags(tags) {
 
   let tagFound = false;
 
-  return tags.reduce((result, tag) => {
+  return mapped.reduce((result: typeof mapped, tag) => {
     if (tag.name.match(/\d+\.\d+\.\d+/)) {
       tagFound = true;
     } else if (tagFound) {
@@ -22,7 +29,7 @@ function mapTags(tags) {
   }, []);
 }
 
-export async function dockerCleanTags(context) {
+export async function dockerCleanTags(context: CmContext) {
   const {
     logger,
     config: { DOCKER_HUB_ID, DOCKER_HUB_PWD, DOCKER_REPOSITORY }