@capraconsulting/cals-cli 3.11.4 → 3.12.1

package/lib/cache.d.ts

@@ -1,4 +1,4 @@
-import { Config } from "./config";
+import type { Config } from "./config";
 interface CacheItem<T> {
     cacheTime: ReturnType<Date["getTime"]>;
     data: T;

package/lib/cals-cli.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import process$2 from 'node:process';
 import semver from 'semver';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -6,31 +7,50 @@ import fs from 'node:fs';
 import yaml from 'js-yaml';
 import pMap from 'p-map';
 import AJV from 'ajv';
+import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import keytar from 'keytar';
-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 keytar from 'keytar';
+import { deprecate } from 'node:util';
+import path from 'node:path';
+import https from 'node:https';
+import os from 'node:os';
 import cachedir from 'cachedir';
-import https from 'https';
-import os from 'os';
+import readline from 'node:readline';
 import chalk from 'chalk';
-import readline from 'readline';
 import { sprintf } from 'sprintf-js';
 import { read } from 'read';
 import { findUp } from 'find-up';
 import { execa } from 'execa';
 
-var version = "3.11.4";
+var version = "3.12.1";
 var engines = {
 	node: ">=12.0.0"
 };
 
+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);
+}
+
 var type = "object";
 var properties = {
 	snyk: {
@@ -325,26 +345,6 @@ 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}`;
 }
@@ -378,8 +378,7 @@ function requireValidDefinition(definition) {
     }, []);
     // Verify team members exists as users.
     definition.github.teams
-        .map((it) => it.teams)
-        .flat()
+        .flatMap((it) => it.teams)
         .forEach((team) => {
         team.members.forEach((login) => {
             if (!loginList.includes(login)) {
@@ -415,9 +414,7 @@ function requireValidDefinition(definition) {
     });
     // Verify no duplicates in repos.
     definition.projects
-        .flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name)))
-        .flat())
+        .flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name))))
         .reduce((acc, repoName) => {
         if (acc.includes(repoName)) {
             throw new Error(`Duplicate repo: ${repoName}`);
@@ -445,20 +442,18 @@ class DefinitionFile {
 function parseDefinition(value) {
     const result = checkAgainstSchema(yaml.load(value));
     if ("error" in result) {
-        throw new Error("Definition content invalid: " + result.error);
+        throw new Error(`Definition content invalid: ${result.error}`);
     }
     requireValidDefinition(result.definition);
     return result.definition;
 }
 function getRepos(definition) {
-    return definition.projects.flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => ({
+    return definition.projects.flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => ({
         id: getRepoId(org.organization, repo.name),
         orgName: org.organization,
         project,
         repo,
-    })))
-        .flat());
+    }))));
 }
 function getGitHubOrgs(definition) {
     const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
@@ -537,13 +532,10 @@ async function undefinedForNotFound(value) {
         return await value;
     }
     catch (e) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (e.name === "HttpError" && e.status === 404) {
             return undefined;
         }
-        else {
-            throw e;
-        }
+        throw e;
     }
 }
 
@@ -562,17 +554,14 @@ class GitHubService {
         // can maximize concurrency all other places.
         this.semaphore = pLimit(6);
         this.octokit.hook.wrap("request", async (request, options) => {
-            /* eslint-disable @typescript-eslint/no-unsafe-member-access */
             this._requestCount++;
             if (options.method !== "GET") {
                 return this.semaphore(() => request(options));
             }
             // Try to cache ETag for GET requests to save on rate limiting.
             // Hits on ETag does not count towards rate limiting.
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const rest = {
                 ...options,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             };
             delete rest.method;
             delete rest.baseUrl;
@@ -623,7 +612,6 @@ class GitHubService {
                 });
             }
             return response;
-            /* eslint-enable @typescript-eslint/no-unsafe-member-access */
         });
     }
     _requestCount = 0;
@@ -663,11 +651,11 @@ class GitHubService {
             throw new Error(`Response from GitHub not OK (${response.status}): ${await response.text()}`);
         }
         const json = (await response.json());
-        if (!!json.errors) {
+        if (json.errors) {
             throw new Error(`Error from GitHub GraphQL API: ${JSON.stringify(json.errors)}`);
         }
         if (json.data == null) {
-            throw new Error(`No data received from GitHub GraphQL API (unknown reason)`);
+            throw new Error("No data received from GitHub GraphQL API (unknown reason)");
         }
         return json.data;
     }
@@ -900,7 +888,6 @@ class GitHubService {
             return true;
         }
         catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             if (e.status === 404) {
                 return false;
             }
@@ -1168,8 +1155,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else if (snykProject.origin === "cli" &&
-        snykProject.remoteRepoUrl != null) {
+    if (snykProject.origin === "cli" && snykProject.remoteRepoUrl != null) {
         // 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);
@@ -1181,9 +1167,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else {
-        return undefined;
-    }
+    return undefined;
 }
 function getGitHubRepoId(repo) {
     return repo ? `${repo.owner}/${repo.name}` : undefined;
@@ -1226,7 +1210,7 @@ class CacheProvider {
         const cacheItem = this.mustValidate
             ? undefined
             : this.retrieveJson(cachekey);
-        const expire = new Date(new Date().getTime() - cachetime * 1000).getTime();
+        const expire = new Date(Date.now() - cachetime * 1000).getTime();
         if (cacheItem !== undefined && cacheItem.cacheTime > expire) {
             return cacheItem.data;
         }
@@ -1264,7 +1248,6 @@ class Config {
             return {};
         }
         try {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return JSON.parse(fs.readFileSync(this.configFile, "utf-8"));
         }
         catch (e) {
@@ -1575,7 +1558,7 @@ function buildGitHubUsersList(definition, members) {
     });
     return reorderListToSimilarAsBefore(definition.github.users, result, (it) => it.login);
 }
-async function dumpSetup(config, reporter, github, snyk, outfile, definitionFile) {
+async function dumpSetup(_config, reporter, github, snyk, outfile, definitionFile) {
     reporter.info("Fetching data. This might take some time");
     const definition = await definitionFile.getDefinition();
     const orgs = await getOrgs(github, getGitHubOrgs(definition));
@@ -1593,13 +1576,9 @@ async function dumpSetup(config, reporter, github, snyk, outfile, definitionFile
     // TODO: An earlier version we had preserved comments by using yawn-yaml
     //  package. However it often produced invalid yaml, so we have removed
     //  it. We might want to revisit it to preserve comments.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-explicit-any
     const doc = yaml.load(await definitionFile.getContents());
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     doc.snyk = generatedDefinition.snyk;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     doc.projects = generatedDefinition.projects;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     doc.github = generatedDefinition.github;
     // Convert to/from plain JSON so that undefined elements are removed.
     fs.writeFileSync(outfile, yaml.dump(JSON.parse(JSON.stringify(doc))));
@@ -1645,7 +1624,7 @@ const command$f = {
         .command(command$h)
         .command(command$g)
         .demandCommand()
-        .usage(`cals definition`),
+        .usage("cals definition"),
     handler: () => {
         yargs(hideBin(process$2.argv)).showHelp();
     },
@@ -1717,7 +1696,7 @@ const command$c = {
             cache: createCacheProvider(config, argv),
         });
         const reporter = createReporter(argv);
-        return analyzeDirectory(reporter, config, github, argv["org"]);
+        return analyzeDirectory(reporter, config, github, argv.org);
     },
 };
 
@@ -2070,27 +2049,28 @@ async function executeChangeSetItem(github, changeItem, reporter, lookup) {
                 username: changeItem.user,
             });
             return true;
-        case "repo-update":
+        case "repo-update": {
             const upd = {
                 owner: changeItem.org,
                 repo: changeItem.repo,
             };
             for (const attrib of changeItem.attribs) {
                 if ("archived" in attrib) {
-                    upd.archived = attrib["archived"];
+                    upd.archived = attrib.archived;
                 }
                 else if ("issues" in attrib) {
-                    upd.has_issues = attrib["issues"];
+                    upd.has_issues = attrib.issues;
                 }
                 else if ("wiki" in attrib) {
-                    upd.has_wiki = attrib["wiki"];
+                    upd.has_wiki = attrib.wiki;
                 }
                 else if ("private" in attrib) {
-                    upd.private = attrib["private"];
+                    upd.private = attrib.private;
                 }
             }
             await github.octokit.repos.update(upd);
             return true;
+        }
         case "repo-team-remove":
             await github.octokit.teams.removeRepoInOrg({
                 org: changeItem.org,
@@ -2135,18 +2115,16 @@ function createOrgGetter(github) {
         }
         return semaphores[orgName];
     }
-    return async function (orgName) {
-        return await getSemaphore(orgName)(async () => {
-            if (!(orgName in orgs)) {
-                const org = await github.getOrg(orgName);
-                orgs[orgName] = {
-                    org,
-                    teams: await github.getTeamList(org),
-                };
-            }
-            return orgs[orgName];
-        });
-    };
+    return async (orgName) => await getSemaphore(orgName)(async () => {
+        if (!(orgName in orgs)) {
+            const org = await github.getOrg(orgName);
+            orgs[orgName] = {
+                org,
+                teams: await github.getTeamList(org),
+            };
+        }
+        return orgs[orgName];
+    });
 }
 async function process(reporter, github, definition, getOrg, execute, limitToOrg) {
     let changes = [];
@@ -2174,16 +2152,16 @@ async function process(reporter, github, definition, getOrg, execute, limitToOrg
     if (ignored.length > 0) {
         reporter.info("Not implemented:");
         for (const change of ignored) {
-            reporter.info("  - " + JSON.stringify(change));
+            reporter.info(`  - ${JSON.stringify(change)}`);
         }
     }
     if (changes.length === 0) {
-        reporter.info(`No actions to be performed`);
+        reporter.info("No actions to be performed");
     }
     else {
-        reporter.info(`To be performed:`);
+        reporter.info("To be performed:");
         for (const change of changes) {
-            reporter.info("  - " + JSON.stringify(change));
+            reporter.info(`  - ${JSON.stringify(change)}`);
         }
     }
     if (execute && changes.length > 0) {
@@ -2224,7 +2202,7 @@ const command$b = {
         const definition = await getDefinitionFile(argv).getDefinition();
         await reportRateLimit(reporter, github, async () => {
             const orgGetter = createOrgGetter(github);
-            await process(reporter, github, definition, orgGetter, !!argv["execute"], argv["org"]);
+            await process(reporter, github, definition, orgGetter, !!argv.execute, argv.org);
         });
     },
 };
@@ -2315,7 +2293,7 @@ const command$a = {
             topic: argv.topic,
             excludeExisting: !!argv["exclude-existing"],
             group: argv.group,
-            org: argv["org"],
+            org: argv.org,
         });
     },
 };
@@ -2324,7 +2302,7 @@ async function listPullRequestsStats({ reporter, github, }) {
     // This is only an initial attempt to get some insights into
     // open pull requests. Feel free to change.
     const pulls = await github.getSearchedPullRequestList("capralifecycle");
-    const cutoffOld = new Date(new Date().getTime() - 86400 * 1000 * 60);
+    const cutoffOld = new Date(Date.now() - 86400 * 1000 * 60);
     const categories = pulls
         .reduce((acc, cur) => {
         const key = `${cur.baseRepository.owner.login}/${cur.baseRepository.name}`;
@@ -2502,13 +2480,13 @@ const command$8 = {
             topic: argv.topic,
             compact: !!argv.compact,
             csv: !!argv.csv,
-            org: argv["org"],
+            org: argv.org,
         });
     },
 };
 
 const e = encodeURIComponent;
-async function listWebhooks(reporter, cache, github, org) {
+async function listWebhooks(reporter, _cache, github, org) {
     const repos = (await github.getOrgRepoList({ org })).filter((it) => !it.isArchived);
     for (const repo of repos) {
         reporter.log("");
@@ -2549,7 +2527,7 @@ const command$7 = {
     handler: async (argv) => {
         const config = createConfig();
         const cacheProvider = createCacheProvider(config, argv);
-        await listWebhooks(createReporter(argv), cacheProvider, await createGitHubService({ config, cache: cacheProvider }), argv["org"]);
+        await listWebhooks(createReporter(argv), cacheProvider, await createGitHubService({ config, cache: cacheProvider }), argv.org);
     },
 };
 
@@ -2605,7 +2583,7 @@ function parseShortlogSummary(value) {
     const matches = [...value.matchAll(/^\s*(\d+)\s+(.+)$/gm)];
     return matches.map((it) => ({
         name: it[2],
-        count: parseInt(it[1]),
+        count: Number.parseInt(it[1]),
     }));
 }
 
@@ -2636,7 +2614,6 @@ class GitRepo {
             await this.logCommand(result);
         }
         catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             await this.logCommand(e);
             throw e;
         }
@@ -2650,7 +2627,6 @@ class GitRepo {
             return result;
         }
         catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             await this.logCommand(e);
             throw e;
         }
@@ -2771,9 +2747,7 @@ function formatAuthorAndCount(reporter, name, count) {
     if (isBotAuthor(name)) {
         return reporter.format.grey(text);
     }
-    else {
-        return reporter.format.greenBright(text);
-    }
+    return reporter.format.greenBright(text);
 }
 async function updateRepos(reporter, foundRepos) {
     const updateResults = await updateReposInParallel(reporter, foundRepos);
@@ -2860,12 +2834,12 @@ function getExpectedRepo(item) {
 }
 function getGitRepo(rootdir, relpath) {
     return new GitRepo(path.resolve(rootdir, relpath), async (result) => {
-        await appendFile(path.resolve(rootdir, CALS_LOG), JSON.stringify({
+        await appendFile(path.resolve(rootdir, CALS_LOG), `${JSON.stringify({
             time: new Date().toISOString(),
             context: relpath,
             type: "exec-result",
             payload: result,
-        }) + "\n");
+        })}\n`);
     });
 }
 function getDefinitionRepo(rootdir, reposInOrg, cals) {
@@ -3067,7 +3041,6 @@ async function loadCalsManifest(config, reporter) {
     }
     // TODO: Verify file has expected contents.
     //  (Can we easily generate schema for type and verify?)
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-explicit-any
     const cals = yaml.load(fs.readFileSync(p, "utf-8"));
     if (cals.version !== 2) {
         throw new Error(`Unexpected version in ${p}`);
@@ -3089,7 +3062,8 @@ const command$5 = {
         .option("ask-move", {
         describe: "Ask to actual move renamed repos",
         type: "boolean",
-    }).usage(`cals github sync
+    })
+        .usage(`cals github sync
 
 Synchronize all checked out GitHub repositories within the working directory
 grouped by the project in the resource definition file. The command can also
@@ -3157,7 +3131,8 @@ const command$4 = {
         .command(command$7)
         .command(command$6)
         .command(command$5)
-        .demandCommand().usage(`cals github
+        .demandCommand()
+        .usage(`cals github
 
 Notes:
   Before doing anything against GitHub you need to configure a token
@@ -3311,7 +3286,11 @@ const command$1 = {
 const command = {
     command: "snyk",
     describe: "Integration with Snyk",
-    builder: (yargs) => yargs.command(command$2).command(command$3).command(command$1).demandCommand()
+    builder: (yargs) => yargs
+        .command(command$2)
+        .command(command$3)
+        .command(command$1)
+        .demandCommand()
         .usage(`cals snyk
 
 Notes:
@@ -3330,7 +3309,7 @@ async function main() {
         process$2.exit(1);
     }
     await yargs(hideBin(process$2.argv))
-        .usage(`cals-cli v${version} (build: ${"2025-06-19T12:44:31+0000"})`)
+        .usage(`cals-cli v${version} (build: ${"2025-08-07T05:46:58+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/definition/dump-setup.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/definition/validate.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/definition.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import { type CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/delete-cache.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/getting-started.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/analyze-directory.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

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

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/generate-clone-commands.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import { type CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/list-pull-requests-stats.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/list-repos.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/list-webhooks.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/set-token.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

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

@@ -1,5 +1,5 @@
-import { CommandModule } from "yargs";
-import { DefinitionRepo } from "../../../definition/types";
+import type { CommandModule } from "yargs";
+import type { DefinitionRepo } from "../../../definition/types";
 interface Alias {
     group: string;
     name: string;

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

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

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

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import { type CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/snyk/report.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/snyk/set-token.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/snyk/sync.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/snyk.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import { type CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/util.d.ts

@@ -1,4 +1,4 @@
-import { Arguments, Options } from "yargs";
+import type { Arguments, Options } from "yargs";
 import { CacheProvider } from "../cache";
 import { Config } from "../config";
 import { DefinitionFile } from "../definition";