@capraconsulting/cals-cli 3.8.0 → 3.10.0

package/README.md

@@ -71,7 +71,6 @@ https://snyk.docs.apiary.io/reference/projects
 - [ ] Detect active vs disabled projects in Snyk (no way through API now?)
 - [x] Report issues in Snyk grouped by our projects
 
-
 ## Contributing
 
 This project doesn't currently accept contributions. For inquiries, please contact the maintainers at [Slack](https://liflig.slack.com/archives/C02T4KTPYS2).

package/lib/cals-cli.mjs

@@ -2,17 +2,18 @@
 import semver from 'semver';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import fs from 'fs';
+import fs from 'node:fs';
 import yaml from 'js-yaml';
-import { uniq, keyBy, sortBy, groupBy, sumBy, repeat } from 'lodash-es';
 import pMap from 'p-map';
 import AJV from 'ajv';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
 import keytar from 'keytar';
-import * as process$2 from 'process';
+import process$2 from 'node:process';
+import * as process$1 from 'process';
 import { performance } from 'perf_hooks';
+import { Buffer } from 'node:buffer';
 import { deprecate } from 'util';
 import path from 'path';
 import rimraf from 'rimraf';
@@ -26,7 +27,7 @@ import read from 'read';
 import findUp from 'find-up';
 import execa from 'execa';
 
-var version = "3.8.0";
+var version = "3.10.0";
 var engines = {
 	node: ">=12.0.0"
 };
@@ -325,6 +326,26 @@ var schema = {
 	$schema: $schema
 };
 
+function groupBy(array, iteratee) {
+    return array.reduce((result, item) => {
+        const key = iteratee(item);
+        if (!result[key]) {
+            result[key] = [];
+        }
+        result[key].push(item);
+        return result;
+    }, {});
+}
+function uniq(array) {
+    return Array.from(new Set(array));
+}
+function sortBy(arr, getKey) {
+    return [...arr].sort((a, b) => getKey(a).localeCompare(getKey(b)));
+}
+function sumBy(array, iteratee) {
+    return array.reduce((sum, item) => sum + iteratee(item), 0);
+}
+
 function getTeamId(org, teamName) {
     return `${org}/${teamName}`;
 }
@@ -441,19 +462,20 @@ function getRepos(definition) {
         .flat());
 }
 function getGitHubOrgs(definition) {
-    return uniq(definition.projects.flatMap((project) => project.github.map((it) => it.organization)));
+    const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
+    return uniq(githubOrganizations);
 }
 
 class GitHubTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "github-token";
     async getToken() {
-        if (process.env.CALS_GITHUB_TOKEN) {
-            return process.env.CALS_GITHUB_TOKEN;
+        if (process$2.env.CALS_GITHUB_TOKEN) {
+            return process$2.env.CALS_GITHUB_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process.stderr.write("No token found. Register using `cals github set-token`\n");
+            process$2.stderr.write("No token found. Register using `cals github set-token`\n");
             return undefined;
         }
         return result;
@@ -631,7 +653,7 @@ class GitHubService {
             return result;
         });
         if (response.status === 401) {
-            process$2.stderr.write("Unauthorized\n");
+            process$1.stderr.write("Unauthorized\n");
             await this.tokenProvider.markInvalid();
         }
         // If you get 502 after 10s, it is a timeout.
@@ -1027,12 +1049,12 @@ class SnykTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "snyk-token";
     async getToken() {
-        if (process.env.CALS_SNYK_TOKEN) {
-            return process.env.CALS_SNYK_TOKEN;
+        if (process$2.env.CALS_SNYK_TOKEN) {
+            return process$2.env.CALS_SNYK_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process.stderr.write("No token found. Register using `cals snyk set-token`\n");
+            process$2.stderr.write("No token found. Register using `cals snyk set-token`\n");
             return undefined;
         }
         return result;
@@ -1090,7 +1112,7 @@ class SnykService {
                 agent: this.config.agent,
             });
             if (response.status === 401) {
-                process.stderr.write("Unauthorized - removing token\n");
+                process$2.stderr.write("Unauthorized - removing token\n");
                 await this.tokenProvider.markInvalid();
             }
             if (!response.ok) {
@@ -1149,7 +1171,7 @@ function getGitHubRepo(snykProject) {
     }
     else if (snykProject.origin === "cli" &&
         snykProject.remoteRepoUrl != null) {
-        // The remoteRepoUrl can be overriden when using the CLI, so don't
+        // The remoteRepoUrl can be overridden when using the CLI, so don't
         // fail if we cannot extract the value.
         const match = /github.com\/([^/]+)\/(.+)\.git$/.exec(snykProject.remoteRepoUrl);
         if (match === null) {
@@ -1222,7 +1244,7 @@ class CacheProvider {
 }
 
 class Config {
-    cwd = path.resolve(process.cwd());
+    cwd = path.resolve(process$2.cwd());
     configFile = path.join(os.homedir(), ".cals-config.json");
     cacheDir = cachedir("cals-cli");
     agent = new https.Agent({
@@ -1281,14 +1303,11 @@ class Reporter {
         this.nonInteractive = !!opts.nonInteractive;
         this.isVerbose = !!opts.verbose;
     }
-    stdout = process.stdout;
-    stderr = process.stderr;
-    stdin = process.stdin;
-    isTTY = this.stdout.isTTY;
+    stdout = process$2.stdout;
+    stderr = process$2.stderr;
     nonInteractive;
     isVerbose;
     format = chalk;
-    startTime = Date.now();
     error(msg) {
         clearLine(this.stderr);
         this.stderr.write(`${this.format.red("error")} ${msg}\n`);
@@ -1301,10 +1320,6 @@ class Reporter {
         clearLine(this.stderr);
         this.stderr.write(`${this.format.yellow("warning")} ${msg}\n`);
     }
-    success(msg) {
-        clearLine(this.stdout);
-        this.stdout.write(`${this.format.green("success")} ${msg}\n`);
-    }
     info(msg) {
         clearLine(this.stdout);
         this.stdout.write(`${this.format.blue("info")} ${msg}\n`);
@@ -1337,7 +1352,7 @@ function createConfig() {
 const definitionFileOptionName = "definition-file";
 const definitionFileOptionValue = {
     describe: "Path to definition file, which should be the latest resources.yaml file from https://github.com/capralifecycle/resources-definition",
-    required: true,
+    demandOption: true,
     type: "string",
 };
 function getDefinitionFile(argv) {
@@ -1484,7 +1499,7 @@ async function getProjects(github, orgs, definition, snyk) {
     const snykReposPromise = getSnykRepos(snyk, definition);
     const repos = await getReposFromGitHub(github, orgs);
     const snykRepos = await snykReposPromise;
-    const definitionRepos = keyBy(getRepos(definition), (it) => it.id);
+    const definitionRepos = Object.fromEntries(getRepos(definition).map((repo) => [repo.id, repo]));
     const projectGroups = Object.values(repos.reduce((acc, cur) => {
         const org = cur.repository.owner.login;
         const repoId = getRepoId(org, cur.repository.name);
@@ -1633,7 +1648,7 @@ const command$f = {
         .demandCommand()
         .usage(`cals definition`),
     handler: () => {
-        yargs(hideBin(process.argv)).showHelp();
+        yargs(hideBin(process$2.argv)).showHelp();
     },
 };
 
@@ -1738,7 +1753,8 @@ function getChangedRepoAttribs(definitionRepo, actualRepo) {
 async function getUnknownRepos(github, definition, limitToOrg) {
     const knownRepos = getRepos(definition).map((it) => it.id);
     const orgs = getGitHubOrgs(definition).filter((orgName) => limitToOrg === undefined || limitToOrg === orgName);
-    return sortBy((await pMap(orgs, (orgName) => github.getOrgRepoList({ org: orgName })))
+    const orgRepoList = await pMap(orgs, (orgName) => github.getOrgRepoList({ org: orgName }));
+    return sortBy(orgRepoList
         .flat()
         .filter((it) => !knownRepos.includes(`${it.owner.login}/${it.name}`)), (it) => `${it.owner.login}/${it.name}`);
 }
@@ -2150,7 +2166,7 @@ function createOrgGetter(github) {
         });
     };
 }
-async function process$1(reporter, github, definition, getOrg, execute, limitToOrg) {
+async function process(reporter, github, definition, getOrg, execute, limitToOrg) {
     let changes = [];
     for (const orgName of getGitHubOrgs(definition)) {
         if (limitToOrg !== undefined && limitToOrg !== orgName) {
@@ -2234,14 +2250,14 @@ const command$b = {
         const definition = await getDefinitionFile(argv).getDefinition();
         await reportRateLimit(reporter, github, async () => {
             const orgGetter = createOrgGetter(github);
-            await process$1(reporter, github, definition, orgGetter, !!argv["execute"], argv["org"]);
+            await process(reporter, github, definition, orgGetter, !!argv["execute"], argv["org"]);
         });
     },
 };
 
 async function generateCloneCommands({ reporter, config, github, org, ...opt }) {
     if (!opt.listGroups && !opt.all && opt.group === undefined) {
-        yargs(hideBin(process.argv)).showHelp();
+        yargs(hideBin(process$2.argv)).showHelp();
         return;
     }
     const repos = await github.getOrgRepoList({ org });
@@ -2265,7 +2281,7 @@ async function generateCloneCommands({ reporter, config, github, org, ...opt })
             .forEach((repo) => {
             // The output of this is used to pipe into e.g. bash.
             // We cannot use reporter.log as it adds additional characters.
-            process.stdout.write(sprintf('[ ! -e "%s" ] && git clone %s\n', repo.name, repo.sshUrl));
+            process$2.stdout.write(sprintf('[ ! -e "%s" ] && git clone %s\n', repo.name, repo.sshUrl));
         });
     });
 }
@@ -2277,7 +2293,7 @@ const command$a = {
         describe: "Group to generate commands for",
     })
         .options("org", {
-        required: true,
+        demandOption: true,
         describe: "Specify GitHub organization",
         type: "string",
     })
@@ -2409,7 +2425,7 @@ async function listRepos({ reporter, github, includeArchived, name = undefined,
     }
     // All CSV output is done using direct stdout to avoid extra chars.
     if (csv) {
-        process.stdout.write("reponame,group\n");
+        process$2.stdout.write("reponame,group\n");
     }
     getGroupedRepos(repos).forEach((group) => {
         if (!csv && compact) {
@@ -2422,7 +2438,7 @@ async function listRepos({ reporter, github, includeArchived, name = undefined,
         group.items.forEach((repo) => {
             if (csv) {
                 // We assume we have no repos or group names with a comma in its name.
-                process.stdout.write(`${repo.name},${group.name}\n`);
+                process$2.stdout.write(`${repo.name},${group.name}\n`);
                 return;
             }
             if (compact) {
@@ -2988,7 +3004,7 @@ async function sync$1({ reporter, github, cals, rootdir, askClone, askMove, }) {
         for (const it of archivedRepos) {
             reporter.info(`  ${it.actualRelpath}`);
         }
-        const thisDirName = path.basename(process.cwd());
+        const thisDirName = path.basename(process$2.cwd());
         const archiveDir = `../${thisDirName}-archive`;
         const hasArchiveDir = fs.existsSync(archiveDir);
         if (hasArchiveDir) {
@@ -3070,7 +3086,7 @@ async function loadCalsManifest(config, reporter) {
     const p = await findUp(CALS_YAML, { cwd: config.cwd });
     if (p === undefined) {
         reporter.error(`File ${CALS_YAML} not found. See help`);
-        process.exitCode = 1;
+        process$2.exitCode = 1;
         return null;
     }
     // TODO: Verify file has expected contents.
@@ -3186,7 +3202,7 @@ Notes:
   option to avoid stale cache. The cache can also be cleared with
   the "cals delete-cache" command.`),
     handler: () => {
-        yargs(hideBin(process.argv)).showHelp();
+        yargs(hideBin(process$2.argv)).showHelp();
     },
 };
 
@@ -3198,7 +3214,7 @@ function totalSeverityCount(project) {
 }
 function buildStatsLine(stats) {
     function item(num, str) {
-        return num === 0 ? repeat(" ", str.length + 4) : sprintf("%3d %s", num, str);
+        return num === 0 ? " ".repeat(str.length + 4) : sprintf("%3d %s", num, str);
     }
     return sprintf("%s  %s  %s  %s", item(stats.critical ?? 0, "critical"), item(stats.high, "high"), item(stats.medium, "medium"), item(stats.low, "low"));
 }
@@ -3334,17 +3350,17 @@ Notes:
   and provide a link to generate one:
   $ cals snyk set-token`),
     handler: () => {
-        yargs(hideBin(process.argv)).showHelp();
+        yargs(hideBin(process$2.argv)).showHelp();
     },
 };
 
 async function main() {
-    if (!semver.satisfies(process.version, engines.node)) {
-        console.error(`Required node version ${engines.node} not satisfied with current version ${process.version}.`);
-        process.exit(1);
+    if (!semver.satisfies(process$2.version, engines.node)) {
+        console.error(`Required node version ${engines.node} not satisfied with current version ${process$2.version}.`);
+        process$2.exit(1);
     }
-    await yargs(hideBin(process.argv))
-        .usage(`cals-cli v${version} (build: ${"2024-12-14T14:07:08+0000"})`)
+    await yargs(hideBin(process$2.argv))
+        .usage(`cals-cli v${version} (build: ${"2025-01-10T09:38:35+0000"})`)
         .scriptName("cals")
         .locale("en")
         .help("help")

package/lib/cals-cli.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cals-cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"cals-cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/cli/commands/github/util.d.ts

@@ -1,3 +1,3 @@
-import { GitHubService } from "../../../github/service";
+import { GitHubService } from "../../../github";
 import { Reporter } from "../../reporter";
 export declare function reportRateLimit(reporter: Reporter, github: GitHubService, block: () => Promise<void>): Promise<void>;

package/lib/cli/reporter.d.ts

@@ -10,17 +10,11 @@ export declare class Reporter {
     stderr: NodeJS.WriteStream & {
         fd: 2;
     };
-    stdin: NodeJS.ReadStream & {
-        fd: 0;
-    };
-    isTTY: boolean;
     nonInteractive: boolean;
     isVerbose: boolean;
     format: typeof chalk;
-    startTime: number;
     error(msg: string): void;
     log(msg: string): void;
     warn(msg: string): void;
-    success(msg: string): void;
     info(msg: string): void;
 }

package/lib/cli/util.d.ts

@@ -1,7 +1,7 @@
 import { Arguments, Options } from "yargs";
 import { CacheProvider } from "../cache";
 import { Config } from "../config";
-import { DefinitionFile } from "../definition/definition";
+import { DefinitionFile } from "../definition";
 import { Reporter } from "./reporter";
 export declare function createReporter(argv: Record<string, unknown>): Reporter;
 export declare function createCacheProvider(config: Config, argv: Record<string, unknown>): CacheProvider;

package/lib/collections/collections.d.ts

@@ -0,0 +1,4 @@
+export declare function groupBy<T>(array: T[], iteratee: (item: T) => string): Record<string, T[]>;
+export declare function uniq<T>(array: T[]): T[];
+export declare function sortBy<T>(arr: T[], getKey: (item: T) => string): T[];
+export declare function sumBy<T>(array: T[], iteratee: (item: T) => number): number;

package/lib/collections/collections.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/definition/definition.d.ts

@@ -3,7 +3,7 @@ import { Definition, GetReposResponse } from "./types";
 export { schema };
 export declare function getRepoId(orgName: string, repoName: string): string;
 export declare class DefinitionFile {
-    private path;
+    private readonly path;
     constructor(path: string);
     getContents(): Promise<string>;
     getDefinition(): Promise<Definition>;

package/lib/index.d.ts

@@ -2,8 +2,8 @@ import { CacheProvider } from "./cache";
 import { Reporter } from "./cli/reporter";
 import { createReporter } from "./cli/util";
 import { Config } from "./config";
-import { DefinitionFile } from "./definition/definition";
-import { createGitHubService, GitHubService } from "./github/service";
+import { DefinitionFile } from "./definition";
+import { createGitHubService, GitHubService } from "./github";
 export declare const VERSION: string;
 export * as definition from "./definition";
 export * as github from "./github";

package/lib/index.es.js

@@ -1,27 +1,28 @@
-import fs from 'fs';
+import fs from 'node:fs';
 import path from 'path';
 import rimraf from 'rimraf';
 import chalk from 'chalk';
 import readline from 'readline';
+import process$1 from 'node:process';
 import 'util';
 import cachedir from 'cachedir';
 import https from 'https';
 import os from 'os';
 import AJV from 'ajv';
 import yaml from 'js-yaml';
-import { uniq } from 'lodash-es';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
 import keytar from 'keytar';
-import * as process$1 from 'process';
+import * as process from 'process';
 import { performance } from 'perf_hooks';
+import { Buffer } from 'node:buffer';
 import { strict } from 'assert';
 import execa from 'execa';
 import read from 'read';
 import { Transform } from 'stream';
 
-var version = "3.8.0";
+var version = "3.10.0";
 
 class CacheProvider {
     constructor(config) {
@@ -86,14 +87,11 @@ class Reporter {
         this.nonInteractive = !!opts.nonInteractive;
         this.isVerbose = !!opts.verbose;
     }
-    stdout = process.stdout;
-    stderr = process.stderr;
-    stdin = process.stdin;
-    isTTY = this.stdout.isTTY;
+    stdout = process$1.stdout;
+    stderr = process$1.stderr;
     nonInteractive;
     isVerbose;
     format = chalk;
-    startTime = Date.now();
     error(msg) {
         clearLine(this.stderr);
         this.stderr.write(`${this.format.red("error")} ${msg}\n`);
@@ -106,10 +104,6 @@ class Reporter {
         clearLine(this.stderr);
         this.stderr.write(`${this.format.yellow("warning")} ${msg}\n`);
     }
-    success(msg) {
-        clearLine(this.stdout);
-        this.stdout.write(`${this.format.green("success")} ${msg}\n`);
-    }
     info(msg) {
         clearLine(this.stdout);
         this.stdout.write(`${this.format.blue("info")} ${msg}\n`);
@@ -117,7 +111,7 @@ class Reporter {
 }
 
 class Config {
-    cwd = path.resolve(process.cwd());
+    cwd = path.resolve(process$1.cwd());
     configFile = path.join(os.homedir(), ".cals-config.json");
     cacheDir = cachedir("cals-cli");
     agent = new https.Agent({
@@ -460,6 +454,10 @@ var schema = {
 	$schema: $schema
 };
 
+function uniq(array) {
+    return Array.from(new Set(array));
+}
+
 function getTeamId(org, teamName) {
     return `${org}/${teamName}`;
 }
@@ -576,9 +574,19 @@ function getRepos(definition) {
         .flat());
 }
 function getGitHubOrgs(definition) {
-    return uniq(definition.projects.flatMap((project) => project.github.map((it) => it.organization)));
+    const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
+    return uniq(githubOrganizations);
 }
 
+var index$3 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  DefinitionFile: DefinitionFile,
+  getGitHubOrgs: getGitHubOrgs,
+  getRepoId: getRepoId,
+  getRepos: getRepos,
+  parseDefinition: parseDefinition
+});
+
 function createReporter(argv) {
     return new Reporter({
         verbose: !!argv.verbose,
@@ -590,12 +598,12 @@ class GitHubTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "github-token";
     async getToken() {
-        if (process.env.CALS_GITHUB_TOKEN) {
-            return process.env.CALS_GITHUB_TOKEN;
+        if (process$1.env.CALS_GITHUB_TOKEN) {
+            return process$1.env.CALS_GITHUB_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process.stderr.write("No token found. Register using `cals github set-token`\n");
+            process$1.stderr.write("No token found. Register using `cals github set-token`\n");
             return undefined;
         }
         return result;
@@ -728,7 +736,7 @@ class GitHubService {
             return result;
         });
         if (response.status === 401) {
-            process$1.stderr.write("Unauthorized\n");
+            process.stderr.write("Unauthorized\n");
             await this.tokenProvider.markInvalid();
         }
         // If you get 502 after 10s, it is a timeout.
@@ -1120,15 +1128,6 @@ async function createGitHubService(props) {
     });
 }
 
-var index$3 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  DefinitionFile: DefinitionFile,
-  getGitHubOrgs: getGitHubOrgs,
-  getRepoId: getRepoId,
-  getRepos: getRepos,
-  parseDefinition: parseDefinition
-});
-
 var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createGitHubService: createGitHubService,
@@ -1139,12 +1138,12 @@ class SnykTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "snyk-token";
     async getToken() {
-        if (process.env.CALS_SNYK_TOKEN) {
-            return process.env.CALS_SNYK_TOKEN;
+        if (process$1.env.CALS_SNYK_TOKEN) {
+            return process$1.env.CALS_SNYK_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process.stderr.write("No token found. Register using `cals snyk set-token`\n");
+            process$1.stderr.write("No token found. Register using `cals snyk set-token`\n");
             return undefined;
         }
         return result;
@@ -1202,7 +1201,7 @@ class SnykService {
                 agent: this.config.agent,
             });
             if (response.status === 401) {
-                process.stderr.write("Unauthorized - removing token\n");
+                process$1.stderr.write("Unauthorized - removing token\n");
                 await this.tokenProvider.markInvalid();
             }
             if (!response.ok) {
@@ -1261,7 +1260,7 @@ function getGitHubRepo(snykProject) {
     }
     else if (snykProject.origin === "cli" &&
         snykProject.remoteRepoUrl != null) {
-        // The remoteRepoUrl can be overriden when using the CLI, so don't
+        // The remoteRepoUrl can be overridden when using the CLI, so don't
         // fail if we cannot extract the value.
         const match = /github.com\/([^/]+)\/(.+)\.git$/.exec(snykProject.remoteRepoUrl);
         if (match === null) {
@@ -1290,10 +1289,10 @@ var index$1 = /*#__PURE__*/Object.freeze({
 
 class SonarCloudTokenCliProvider {
     async getToken() {
-        if (process.env.CALS_SONARCLOUD_TOKEN) {
-            return Promise.resolve(process.env.CALS_SONARCLOUD_TOKEN);
+        if (process$1.env.CALS_SONARCLOUD_TOKEN) {
+            return Promise.resolve(process$1.env.CALS_SONARCLOUD_TOKEN);
         }
-        process.stderr.write("No environmental variable found. Set variable `CALS_SONARCLOUD_TOKEN` to token value\n");
+        process$1.stderr.write("No environmental variable found. Set variable `CALS_SONARCLOUD_TOKEN` to token value\n");
         return undefined;
     }
     async markInvalid() {
@@ -1326,11 +1325,11 @@ class SonarCloudService {
             agent: this.config.agent,
         });
         if (response.status === 401) {
-            process.stderr.write("Unauthorized - removing token\n");
+            process$1.stderr.write("Unauthorized - removing token\n");
             await this.tokenProvider.markInvalid();
         }
         if (response.status === 404) {
-            process.stderr.write(`Project ${sonarCloudProjectKey} does not exist in SonarCloud\n`);
+            process$1.stderr.write(`Project ${sonarCloudProjectKey} does not exist in SonarCloud\n`);
             return undefined;
         }
         if (!response.ok) {
@@ -1413,14 +1412,14 @@ class TestExecutor {
             // This will not abort the running tasks until after
             // we have completed the cleanup tasks. The running tasks
             // can stop earlier by calling checkCanContinue.
-            process.on("SIGINT", () => {
+            process$1.on("SIGINT", () => {
                 console.warn("Caught interrupt signal - forcing termination");
                 if (this.cleanupTask != null) {
                     return;
                 }
                 this.shutdown = true;
                 this.cleanupTask = this.runTasks().then(() => {
-                    process.exit(1);
+                    process$1.exit(1);
                 });
             });
             await body(this);
@@ -1428,7 +1427,7 @@ class TestExecutor {
         catch (error) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             console.error(error.stack || error.message || error);
-            process.exitCode = 1;
+            process$1.exitCode = 1;
         }
         finally {
             console.log(`Reached finally block`);
@@ -1621,14 +1620,14 @@ class OutputPrefixTransform extends Transform {
 function pipeToConsole(result, name) {
     result.stdout
         ?.pipe(new OutputPrefixTransform(`${name}: `))
-        .pipe(process.stdout);
+        .pipe(process$1.stdout);
     result.stderr
         ?.pipe(new OutputPrefixTransform(`${name} (stderr): `))
-        .pipe(process.stderr);
+        .pipe(process$1.stderr);
 }
 function checkPidRunning(pid) {
     try {
-        process.kill(pid, 0);
+        process$1.kill(pid, 0);
         return true;
     }
     catch {
@@ -1771,7 +1770,7 @@ async function runNpmRunScript(name, options) {
  * This likely does not cover all situations.
  */
 async function getDockerHostAddress() {
-    if (process.platform === "darwin" || process.platform === "win32") {
+    if (process$1.platform === "darwin" || process$1.platform === "win32") {
         return "host.docker.internal";
     }
     if (fs.existsSync("/.dockerenv")) {
@@ -1782,7 +1781,7 @@ async function getDockerHostAddress() {
             return res.stdout
                 .split("\n")
                 .filter((it) => it.includes("default via"))
-                .map((it) => /default via ([\d\.]+) /.exec(it)[1])[0];
+                .map((it) => /default via ([\d.]+) /.exec(it)[1])[0];
         }
         catch {
             throw new Error("Failed to extract docker host address");

package/lib/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/index.js

@@ -1,27 +1,28 @@
-import fs from 'fs';
+import fs from 'node:fs';
 import path from 'path';
 import rimraf from 'rimraf';
 import chalk from 'chalk';
 import readline from 'readline';
+import process$1 from 'node:process';
 import 'util';
 import cachedir from 'cachedir';
 import https from 'https';
 import os from 'os';
 import AJV from 'ajv';
 import yaml from 'js-yaml';
-import { uniq } from 'lodash-es';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
 import keytar from 'keytar';
-import * as process$1 from 'process';
+import * as process from 'process';
 import { performance } from 'perf_hooks';
+import { Buffer } from 'node:buffer';
 import { strict } from 'assert';
 import execa from 'execa';
 import read from 'read';
 import { Transform } from 'stream';
 
-var version = "3.8.0";
+var version = "3.10.0";
 
 class CacheProvider {
     constructor(config) {
@@ -86,14 +87,11 @@ class Reporter {
         this.nonInteractive = !!opts.nonInteractive;
         this.isVerbose = !!opts.verbose;
     }
-    stdout = process.stdout;
-    stderr = process.stderr;
-    stdin = process.stdin;
-    isTTY = this.stdout.isTTY;
+    stdout = process$1.stdout;
+    stderr = process$1.stderr;
     nonInteractive;
     isVerbose;
     format = chalk;
-    startTime = Date.now();
     error(msg) {
         clearLine(this.stderr);
         this.stderr.write(`${this.format.red("error")} ${msg}\n`);
@@ -106,10 +104,6 @@ class Reporter {
         clearLine(this.stderr);
         this.stderr.write(`${this.format.yellow("warning")} ${msg}\n`);
     }
-    success(msg) {
-        clearLine(this.stdout);
-        this.stdout.write(`${this.format.green("success")} ${msg}\n`);
-    }
     info(msg) {
         clearLine(this.stdout);
         this.stdout.write(`${this.format.blue("info")} ${msg}\n`);
@@ -117,7 +111,7 @@ class Reporter {
 }
 
 class Config {
-    cwd = path.resolve(process.cwd());
+    cwd = path.resolve(process$1.cwd());
     configFile = path.join(os.homedir(), ".cals-config.json");
     cacheDir = cachedir("cals-cli");
     agent = new https.Agent({
@@ -460,6 +454,10 @@ var schema = {
 	$schema: $schema
 };
 
+function uniq(array) {
+    return Array.from(new Set(array));
+}
+
 function getTeamId(org, teamName) {
     return `${org}/${teamName}`;
 }
@@ -576,9 +574,19 @@ function getRepos(definition) {
         .flat());
 }
 function getGitHubOrgs(definition) {
-    return uniq(definition.projects.flatMap((project) => project.github.map((it) => it.organization)));
+    const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
+    return uniq(githubOrganizations);
 }
 
+var index$3 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  DefinitionFile: DefinitionFile,
+  getGitHubOrgs: getGitHubOrgs,
+  getRepoId: getRepoId,
+  getRepos: getRepos,
+  parseDefinition: parseDefinition
+});
+
 function createReporter(argv) {
     return new Reporter({
         verbose: !!argv.verbose,
@@ -590,12 +598,12 @@ class GitHubTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "github-token";
     async getToken() {
-        if (process.env.CALS_GITHUB_TOKEN) {
-            return process.env.CALS_GITHUB_TOKEN;
+        if (process$1.env.CALS_GITHUB_TOKEN) {
+            return process$1.env.CALS_GITHUB_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process.stderr.write("No token found. Register using `cals github set-token`\n");
+            process$1.stderr.write("No token found. Register using `cals github set-token`\n");
             return undefined;
         }
         return result;
@@ -728,7 +736,7 @@ class GitHubService {
             return result;
         });
         if (response.status === 401) {
-            process$1.stderr.write("Unauthorized\n");
+            process.stderr.write("Unauthorized\n");
             await this.tokenProvider.markInvalid();
         }
         // If you get 502 after 10s, it is a timeout.
@@ -1120,15 +1128,6 @@ async function createGitHubService(props) {
     });
 }
 
-var index$3 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  DefinitionFile: DefinitionFile,
-  getGitHubOrgs: getGitHubOrgs,
-  getRepoId: getRepoId,
-  getRepos: getRepos,
-  parseDefinition: parseDefinition
-});
-
 var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createGitHubService: createGitHubService,
@@ -1139,12 +1138,12 @@ class SnykTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "snyk-token";
     async getToken() {
-        if (process.env.CALS_SNYK_TOKEN) {
-            return process.env.CALS_SNYK_TOKEN;
+        if (process$1.env.CALS_SNYK_TOKEN) {
+            return process$1.env.CALS_SNYK_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process.stderr.write("No token found. Register using `cals snyk set-token`\n");
+            process$1.stderr.write("No token found. Register using `cals snyk set-token`\n");
             return undefined;
         }
         return result;
@@ -1202,7 +1201,7 @@ class SnykService {
                 agent: this.config.agent,
             });
             if (response.status === 401) {
-                process.stderr.write("Unauthorized - removing token\n");
+                process$1.stderr.write("Unauthorized - removing token\n");
                 await this.tokenProvider.markInvalid();
             }
             if (!response.ok) {
@@ -1261,7 +1260,7 @@ function getGitHubRepo(snykProject) {
     }
     else if (snykProject.origin === "cli" &&
         snykProject.remoteRepoUrl != null) {
-        // The remoteRepoUrl can be overriden when using the CLI, so don't
+        // The remoteRepoUrl can be overridden when using the CLI, so don't
         // fail if we cannot extract the value.
         const match = /github.com\/([^/]+)\/(.+)\.git$/.exec(snykProject.remoteRepoUrl);
         if (match === null) {
@@ -1290,10 +1289,10 @@ var index$1 = /*#__PURE__*/Object.freeze({
 
 class SonarCloudTokenCliProvider {
     async getToken() {
-        if (process.env.CALS_SONARCLOUD_TOKEN) {
-            return Promise.resolve(process.env.CALS_SONARCLOUD_TOKEN);
+        if (process$1.env.CALS_SONARCLOUD_TOKEN) {
+            return Promise.resolve(process$1.env.CALS_SONARCLOUD_TOKEN);
         }
-        process.stderr.write("No environmental variable found. Set variable `CALS_SONARCLOUD_TOKEN` to token value\n");
+        process$1.stderr.write("No environmental variable found. Set variable `CALS_SONARCLOUD_TOKEN` to token value\n");
         return undefined;
     }
     async markInvalid() {
@@ -1326,11 +1325,11 @@ class SonarCloudService {
             agent: this.config.agent,
         });
         if (response.status === 401) {
-            process.stderr.write("Unauthorized - removing token\n");
+            process$1.stderr.write("Unauthorized - removing token\n");
             await this.tokenProvider.markInvalid();
         }
         if (response.status === 404) {
-            process.stderr.write(`Project ${sonarCloudProjectKey} does not exist in SonarCloud\n`);
+            process$1.stderr.write(`Project ${sonarCloudProjectKey} does not exist in SonarCloud\n`);
             return undefined;
         }
         if (!response.ok) {
@@ -1413,14 +1412,14 @@ class TestExecutor {
             // This will not abort the running tasks until after
             // we have completed the cleanup tasks. The running tasks
             // can stop earlier by calling checkCanContinue.
-            process.on("SIGINT", () => {
+            process$1.on("SIGINT", () => {
                 console.warn("Caught interrupt signal - forcing termination");
                 if (this.cleanupTask != null) {
                     return;
                 }
                 this.shutdown = true;
                 this.cleanupTask = this.runTasks().then(() => {
-                    process.exit(1);
+                    process$1.exit(1);
                 });
             });
             await body(this);
@@ -1428,7 +1427,7 @@ class TestExecutor {
         catch (error) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             console.error(error.stack || error.message || error);
-            process.exitCode = 1;
+            process$1.exitCode = 1;
         }
         finally {
             console.log(`Reached finally block`);
@@ -1621,14 +1620,14 @@ class OutputPrefixTransform extends Transform {
 function pipeToConsole(result, name) {
     result.stdout
         ?.pipe(new OutputPrefixTransform(`${name}: `))
-        .pipe(process.stdout);
+        .pipe(process$1.stdout);
     result.stderr
         ?.pipe(new OutputPrefixTransform(`${name} (stderr): `))
-        .pipe(process.stderr);
+        .pipe(process$1.stderr);
 }
 function checkPidRunning(pid) {
     try {
-        process.kill(pid, 0);
+        process$1.kill(pid, 0);
         return true;
     }
     catch {
@@ -1771,7 +1770,7 @@ async function runNpmRunScript(name, options) {
  * This likely does not cover all situations.
  */
 async function getDockerHostAddress() {
-    if (process.platform === "darwin" || process.platform === "win32") {
+    if (process$1.platform === "darwin" || process$1.platform === "win32") {
         return "host.docker.internal";
     }
     if (fs.existsSync("/.dockerenv")) {
@@ -1782,7 +1781,7 @@ async function getDockerHostAddress() {
             return res.stdout
                 .split("\n")
                 .filter((it) => it.includes("default via"))
-                .map((it) => /default via ([\d\.]+) /.exec(it)[1])[0];
+                .map((it) => /default via ([\d.]+) /.exec(it)[1])[0];
         }
         catch {
             throw new Error("Failed to extract docker host address");

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/snyk/service.d.ts

@@ -1,5 +1,5 @@
 import { Config } from "../config";
-import { Definition } from "../definition/types";
+import { Definition } from "../definition";
 import { SnykTokenProvider } from "./token";
 import { SnykProject } from "./types";
 interface SnykServiceProps {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@capraconsulting/cals-cli",
-  "version": "3.8.0",
+  "version": "3.10.0",
   "description": "CLI for repeatable tasks in CALS",
   "type": "module",
   "license": "Apache-2.0",
   "scripts": {
     "prepare": "tsx scripts/create-definition-schema.ts && husky",
     "build": "rollup -c",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --coverage src",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch src",
+    "test": "vitest run --coverage src",
+    "test:watch": "vitest --coverage src",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "prepack": "./scripts/build-and-verify.sh",
@@ -32,10 +32,10 @@
     "find-up": "^5.0.0",
     "js-yaml": "^4.1.0",
     "keytar": "^7.9.0",
-    "lodash-es": "^4.17.21",
-    "node-fetch": "^2.6.7",
+    "node-fetch": "^3.0.0",
     "p-limit": "^3.0.0",
     "p-map": "^4.0.0",
+    "process": "0.11.10",
     "read": "^1.0.7",
     "rimraf": "^4.0.0",
     "semver": "^7.6.2",
@@ -56,10 +56,9 @@
     "@rollup/plugin-alias": "5.1.1",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-replace": "6.0.1",
-    "@types/jest": "29.5.14",
     "@types/js-yaml": "4.0.9",
     "@types/lodash-es": "4.17.12",
-    "@types/node": "22.10.1",
+    "@types/node": "22.10.5",
     "@types/node-fetch": "2.6.12",
     "@types/read": "0.0.32",
     "@types/rimraf": "3.0.2",
@@ -68,22 +67,22 @@
     "@types/yargs": "17.0.33",
     "@typescript-eslint/eslint-plugin": "8.18.0",
     "@typescript-eslint/parser": "8.18.0",
+    "@vitest/coverage-v8": "2.1.8",
+    "@vitest/ui": "2.1.8",
     "dateformat": "4.6.3",
     "eslint": "9.16.0",
     "eslint-config-prettier": "9.1.0",
     "eslint-plugin-prettier": "5.2.1",
     "husky": "9.1.7",
-    "jest": "^29.6.1",
-    "lodash": "4.17.21",
     "prettier": "3.4.2",
     "rollup": "2.79.2",
     "rollup-plugin-typescript2": "0.36.0",
     "semantic-release": "24.2.0",
     "tempy": "1.0.1",
-    "ts-jest": "^29.1.1",
     "tsx": "4.19.2",
     "typescript": "5.7.2",
-    "typescript-json-schema": "0.65.1"
+    "typescript-json-schema": "0.65.1",
+    "vitest": "2.1.8"
   },
   "files": [
     "lib"