@herodevs/cli 0.2.2 → 0.2.3

package/main.cjs

@@ -0,0 +1,986 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// apps/cli/package.json
+var require_package = __commonJS({
+  "apps/cli/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@herodevs/cli",
+      version: "0.0.0",
+      bin: "./main.cjs",
+      dependencies: {
+        tslib: "^2.3.0"
+      },
+      type: "commonjs",
+      main: "./main.cjs"
+    };
+  }
+});
+
+// apps/cli/src/lib/cli.ts
+var yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+
+// libs/report/committers/src/lib/committers.ts
+var import_date_fns2 = require("date-fns");
+
+// libs/utility/src/lib/get-root-dir.ts
+var import_fs = require("fs");
+var import_path = require("path");
+function getRootDir(directory) {
+  if ((0, import_fs.existsSync)((0, import_path.join)(directory, "package.json"))) {
+    return directory;
+  }
+  return getRootDir((0, import_path.resolve)((0, import_path.join)(directory, "..")));
+}
+
+// libs/utility/src/lib/run-command.ts
+var import_child_process = require("child_process");
+async function runCommand(cmd) {
+  return new Promise((resolve4, reject) => {
+    const options = {
+      timeout: 1e4
+    };
+    (0, import_child_process.exec)(cmd, options, (err, stdout, stderr) => {
+      if (err) {
+        const rejection = {
+          err,
+          stdout,
+          stderr
+        };
+        reject(rejection);
+        return;
+      }
+      let result = stdout;
+      if (typeof stdout === "string") {
+        result = (stdout || "").trim();
+      }
+      resolve4(result);
+    });
+  });
+}
+
+// libs/utility/src/lib/get-project-types.ts
+var import_fs2 = require("fs");
+var path = require("path");
+function getProjectTypes() {
+  const types = [];
+  if ((0, import_fs2.existsSync)(path.join(process.cwd(), "package.json"))) {
+    types.push("npm");
+  }
+  return types;
+}
+
+// libs/utility/src/lib/sort-by-name.ts
+function sortByName(a, b) {
+  return a.name === b.name ? 0 : a.name > b.name ? 1 : -1;
+}
+
+// libs/report/committers/src/lib/parse-date-flags.ts
+var import_date_fns = require("date-fns");
+function parseDateFlags(dateFormat2, startDate, endDate) {
+  return {
+    endDate: (0, import_date_fns.parse)(endDate, dateFormat2, /* @__PURE__ */ new Date()),
+    startDate: (0, import_date_fns.parse)(startDate, dateFormat2, /* @__PURE__ */ new Date())
+  };
+}
+
+// libs/report/committers/src/lib/constants.ts
+var dateFormat = "yyyy-MM-dd";
+var gammaDelimiter = "\u0393\u0393\u0393\u0393";
+var monthsToSubtract = 12;
+var gitOutputFormat = `"${["%h", "%an", "%ad"].join(gammaDelimiter)}"`;
+
+// libs/report/committers/src/lib/parse-git-log-entries.ts
+function parseGitLogEntries(entries) {
+  return entries.map((entry) => {
+    const [commitHash, committer, date] = entry.split(gammaDelimiter);
+    return { commitHash, committer, date: new Date(date) };
+  });
+}
+
+// libs/report/committers/src/lib/get-committer-counts.ts
+function getCommitterCounts(entries) {
+  return entries.reduce((acc, entry) => {
+    let committerCount = acc.find((c) => c.name === entry.committer);
+    if (!committerCount) {
+      committerCount = { name: entry.committer, count: 0 };
+      acc.push(committerCount);
+    }
+    committerCount.count++;
+    return acc;
+  }, []).sort((a, b) => b.count - a.count);
+}
+
+// libs/report/committers/src/lib/committers.ts
+var reportCommittersCommand = {
+  command: "committers",
+  describe: "show git committers",
+  aliases: [],
+  builder: {
+    startDate: {
+      alias: "s",
+      default: (0, import_date_fns2.format)(/* @__PURE__ */ new Date(), dateFormat),
+      describe: `Start Date (format: ${dateFormat})`,
+      string: true
+    },
+    endDate: {
+      alias: "e",
+      describe: `End Date (format: ${dateFormat})`,
+      required: false,
+      default: (0, import_date_fns2.format)((0, import_date_fns2.subMonths)(/* @__PURE__ */ new Date(), monthsToSubtract), dateFormat)
+    },
+    exclude: {
+      alias: "x",
+      array: true,
+      describe: 'Path Exclusions (eg -x="./src/bin" -x="./dist")',
+      required: false
+    },
+    json: {
+      describe: "Output to JSON format",
+      required: false,
+      default: false,
+      boolean: true
+    }
+    // monthly: {
+    //   alias: 'm',
+    //   describe:
+    //     'Break down by calendar month, rather than by committer.  (eg -m)',
+    //   required: false,
+    //   default: false,
+    // },
+  },
+  handler: run
+};
+async function run(args) {
+  const { startDate, endDate } = parseDateFlags(dateFormat, args.startDate, args.endDate);
+  const ignores = args.exclude && args.exclude.length ? `-- . "!(${args.exclude.join("|")})"` : "";
+  const gitCommand = `git log --since "${endDate}" --until "${startDate}" --pretty=format:${gitOutputFormat} ${ignores}`;
+  const result = await runCommand(gitCommand);
+  const rawEntries = result.split("\n");
+  if (rawEntries.length === 1 && rawEntries[0] === "") {
+    const startDateStr = (0, import_date_fns2.format)(startDate, "yyyy-MM-dd");
+    const endDateStr = (0, import_date_fns2.format)(endDate, "yyyy-MM-dd");
+    console.log(`No commits found between ${endDateStr} and ${startDateStr}`);
+    return;
+  }
+  const entries = parseGitLogEntries(rawEntries);
+  const committerCounts = getCommitterCounts(entries);
+  if (args.json) {
+    outputCommittersJson(committerCounts);
+  } else {
+    outputCommitters(committerCounts);
+  }
+}
+function outputCommitters(committerCounts) {
+  const longestNameLength = committerCounts.reduce((acc, c) => {
+    return c.name.length > acc ? c.name.length : acc;
+  }, "Committer".length);
+  const header = `Committer${" ".repeat(longestNameLength - 9)} | Commits`;
+  console.log(header);
+  console.log(
+    header.split("").map((c) => c === "|" ? "|" : "-").join("")
+  );
+  console.log(
+    committerCounts.map((c) => {
+      const committer = `${c.name}${" ".repeat(longestNameLength - c.name.length)}`;
+      const count = " ".repeat(7 - c.count.toString().length) + c.count;
+      return `${committer} | ${count}`;
+    }).join("\n")
+  );
+}
+function outputCommittersJson(committerCounts) {
+  console.log(JSON.stringify(committerCounts, null, 2));
+}
+
+// libs/report/diagnostics/src/lib/diagnostics.ts
+var import_prompts = require("@inquirer/prompts");
+
+// libs/report/diagnostics/src/lib/get-file-contents.ts
+var import_fs3 = require("fs");
+function getFileContents(filePath) {
+  if (!(0, import_fs3.existsSync)(filePath)) {
+    return `${filePath} not found`;
+  }
+  const diagData = (0, import_fs3.readFileSync)(filePath, "utf8");
+  return diagData;
+}
+
+// libs/report/diagnostics/src/lib/get-package-json-section.ts
+function getPackageJsonSection(section) {
+  const filePath = "package.json";
+  const pkg = JSON.parse(getFileContents(filePath));
+  const sectionData = pkg[section];
+  if (!sectionData) {
+    return `${section} not found in package.json`;
+  }
+  const diagData = JSON.stringify(sectionData, null, 2);
+  return diagData;
+}
+
+// libs/report/diagnostics/src/lib/get-diagnostic-types.ts
+function getDiagnosticTypes() {
+  const diagTypeList = [
+    { name: "Package JSON - dependencies", value: "dependencies" },
+    { name: "Package JSON - devDependencies", value: "devDependencies" },
+    { name: "Package JSON - overrides", value: "overrides" },
+    { name: ".npmrc file contents", value: "npmrc" },
+    { name: "npm config", value: "npm config" },
+    { name: "List of installed packages (npm ls)", value: "npm ls" }
+  ];
+  return diagTypeList;
+}
+
+// libs/report/diagnostics/src/lib/diagnostics.ts
+var reportDiagnosticsCommand = {
+  command: "diagnostics",
+  describe: "show diagnostic information",
+  aliases: ["diag", "d"],
+  builder: {
+    all: {
+      describe: "Return all available diagnostics",
+      required: false,
+      default: false,
+      boolean: true
+    },
+    consent: {
+      describe: "Agree to understanding that sensitive data may be outputted",
+      required: false,
+      default: false,
+      boolean: true
+    }
+  },
+  handler: run2
+};
+async function run2(args) {
+  const consentPrompt = "Data produced may contain sensitive data, please review before sharing it.";
+  if (!args.consent) {
+    const answer = await (0, import_prompts.confirm)({
+      message: `${consentPrompt} Continue?`
+    });
+    if (!answer) {
+      return;
+    }
+  } else {
+    console.log(consentPrompt);
+  }
+  const diagTypeList = getDiagnosticTypes().map((d) => ({
+    ...d,
+    checked: true
+  }));
+  const diagTypes = args.all ? diagTypeList.map((d) => d.value) : await (0, import_prompts.checkbox)({
+    message: "select diagnostic(s) to run",
+    choices: diagTypeList,
+    required: true,
+    pageSize: diagTypeList.length
+  });
+  for (let i = 0; i < diagTypes.length; i++) {
+    let output = "";
+    let title = "";
+    switch (diagTypes[i]) {
+      case "dependencies":
+        title = "Package JSON - dependencies";
+        output = getPackageJsonSection("dependencies");
+        break;
+      case "devDependencies":
+        title = "Package JSON - devDependencies";
+        output = getPackageJsonSection("devDependencies");
+        break;
+      case "overrides":
+        title = "Package JSON - overrides";
+        output = getPackageJsonSection("overrides");
+        break;
+      case "npmrc":
+        title = ".npmrc file contents";
+        output = getFileContents(".npmrc");
+        break;
+      case "npm config":
+        try {
+          title = "npm config results";
+          output = await runCommand("npm config get");
+        } catch (e) {
+          output = e.stderr;
+        }
+        break;
+      case "npm ls":
+        title = "npm ls results";
+        output = await runCommand("npm ls --depth=1000");
+        break;
+    }
+    const titleMsg = `*** ${title} ***`;
+    const titleWrapper = "*".repeat(titleMsg.length);
+    console.log(`${titleWrapper}
+${titleMsg}
+${titleWrapper}
+${output}
+`);
+  }
+}
+
+// libs/tracker/init/src/lib/default-config.ts
+var defaultConfig = {
+  categories: {
+    legacy: {
+      fileTypes: ["js", "ts", "html", "css", "scss", "less"],
+      includes: ["./legacy"],
+      jsTsPairs: "js"
+    },
+    modern: {
+      fileTypes: ["ts", "html", "css", "scss", "less"],
+      includes: ["./modern"],
+      jsTsPairs: "ts"
+    }
+  },
+  ignorePatterns: ["node_modules"],
+  outputDir: "hd-tracker"
+};
+
+// libs/tracker/init/src/lib/init.ts
+var import_path2 = require("path");
+var import_fs4 = require("fs");
+var trackerInitCommand = {
+  command: "init",
+  describe: "Initialize the tracker configuration",
+  aliases: [],
+  builder: {},
+  handler: run3
+};
+function run3(args) {
+  const rootDir = getRootDir(global.process.cwd());
+  const output = JSON.stringify(defaultConfig, null, 2);
+  const dir = (0, import_path2.join)(rootDir, "hd-tracker");
+  if (!(0, import_fs4.existsSync)(dir)) {
+    (0, import_fs4.mkdirSync)(dir);
+  }
+  (0, import_fs4.writeFileSync)((0, import_path2.join)(dir, "config.json"), output);
+}
+
+// libs/tracker/shared/src/lib/read-config.ts
+var import_fs5 = require("fs");
+var import_path3 = require("path");
+function readConfig(rootDirectory, optionsPath) {
+  const path3 = optionsPath && (0, import_fs5.existsSync)((0, import_path3.join)(rootDirectory, optionsPath)) ? (0, import_path3.join)(rootDirectory, optionsPath) : (0, import_path3.join)(rootDirectory, "hd-tracker", "config.json");
+  const contents = (0, import_fs5.readFileSync)(path3).toString("utf-8");
+  return JSON.parse(contents);
+}
+
+// libs/tracker/run/src/lib/run.ts
+var import_path6 = require("path");
+
+// libs/tracker/run/src/lib/process-category.ts
+var sloc = __toESM(require("sloc"));
+var import_fs6 = require("fs");
+var import_path4 = require("path");
+function processCategory(rootDirectory, category, ignorePatterns) {
+  console.log(`Processing "${category.name}"...`);
+  const allFiles = category.includes.reduce((acc, include) => {
+    return [...acc, ...findAllFilesInDirectory((0, import_path4.join)(rootDirectory, include))];
+  }, []);
+  const includedFiles = findIncludedFiles(category, ignorePatterns, allFiles);
+  console.log(`     ${includedFiles.length} files...`);
+  const results = includedFiles.map(getFileStats);
+  const resultMap = aggregateResults(results);
+  const aggregatedResults = Object.values(resultMap).map((val) => val);
+  const totals = aggregatedResults.reduce(
+    (totals2, curr) => ({
+      fileCount: totals2.fileCount + curr.fileCount,
+      total: totals2.total + curr.total,
+      source: totals2.source + curr.source,
+      comment: totals2.comment + curr.comment,
+      single: totals2.single + curr.single,
+      block: totals2.block + curr.block,
+      mixed: totals2.mixed + curr.mixed,
+      empty: totals2.empty + curr.empty,
+      todo: totals2.todo + curr.todo,
+      blockEmpty: totals2.blockEmpty + curr.blockEmpty
+    }),
+    {
+      fileCount: 0,
+      total: 0,
+      source: 0,
+      comment: 0,
+      single: 0,
+      block: 0,
+      mixed: 0,
+      empty: 0,
+      todo: 0,
+      blockEmpty: 0
+    }
+  );
+  const final = {
+    name: category.name,
+    totals,
+    fileTypes: aggregatedResults
+  };
+  console.log(`     ${final.totals.total} total lines`);
+  return final;
+}
+function aggregateResults(results) {
+  return results.reduce((acc, result) => {
+    const fileTypeResults = acc[result.fileType];
+    if (!fileTypeResults) {
+      acc[result.fileType] = {
+        fileType: result.fileType,
+        fileCount: 1,
+        total: result.total,
+        source: result.source,
+        comment: result.comment,
+        single: result.single,
+        block: result.block,
+        mixed: result.mixed,
+        empty: result.empty,
+        todo: result.todo,
+        blockEmpty: result.blockEmpty
+      };
+    } else {
+      acc[result.fileType] = {
+        fileType: result.fileType,
+        fileCount: fileTypeResults.fileCount + 1,
+        total: fileTypeResults.total + result.total,
+        source: fileTypeResults.source + result.source,
+        comment: fileTypeResults.comment + result.comment,
+        single: fileTypeResults.single + result.single,
+        block: fileTypeResults.block + result.block,
+        mixed: fileTypeResults.mixed + result.mixed,
+        empty: fileTypeResults.empty + result.empty,
+        todo: fileTypeResults.todo + result.todo,
+        blockEmpty: fileTypeResults.blockEmpty + result.blockEmpty
+      };
+    }
+    return acc;
+  }, {});
+}
+function getFileStats(file) {
+  const contents = (0, import_fs6.readFileSync)(file).toString("utf-8");
+  const fileType = getFileExt(file);
+  const stats = sloc(contents, fileType);
+  return {
+    path: file,
+    fileType,
+    ...stats
+  };
+}
+function findIncludedFiles(category, ignorePatterns, allFiles) {
+  return allFiles.filter((file) => {
+    const ext = getFileExt(file);
+    let shouldBeIncluded = !!category.fileTypes.find(
+      (fileType) => fileType === ext
+    );
+    if (shouldBeIncluded) {
+      ignorePatterns?.forEach((ignorePattern) => {
+        if (file.indexOf(ignorePattern) !== -1) {
+          shouldBeIncluded = false;
+        }
+      });
+    }
+    if (shouldBeIncluded) {
+      category.excludes?.forEach((exclude) => {
+        if (file.indexOf(exclude) !== -1) {
+          shouldBeIncluded = false;
+        }
+      });
+    }
+    return shouldBeIncluded;
+  }).filter((file, _index, files) => {
+    if (category.jsTsPairs === "ignore" || category.jsTsPairs === void 0) {
+      return true;
+    }
+    const fileExtToKeep = category.jsTsPairs;
+    const ext = getFileExt(file);
+    const fileExtToDiscard = fileExtToKeep === "js" ? "ts" : "js";
+    if (fileExtToKeep === ext || fileExtToDiscard !== ext) {
+      return true;
+    }
+    const counterpartExt = ext === "js" ? "ts" : "js";
+    const parts = file.split(".");
+    parts[parts.length - 1] = counterpartExt;
+    const counterpartExists = files.filter((f) => f === parts.join(".")).length !== 0;
+    if (counterpartExists) {
+      return false;
+    }
+    return true;
+  });
+}
+function findAllFilesInDirectory(directory) {
+  const results = (0, import_fs6.readdirSync)(directory);
+  const subfiles = results.filter((result) => (0, import_fs6.lstatSync)((0, import_path4.join)(directory, result)).isDirectory()).reduce((acc, subdir) => {
+    const files2 = findAllFilesInDirectory((0, import_path4.join)(directory, subdir));
+    return [...acc, ...files2];
+  }, []);
+  const files = results.filter((result) => (0, import_fs6.lstatSync)((0, import_path4.join)(directory, result)).isFile()).map((fileName) => (0, import_path4.join)(directory, fileName));
+  return [...files, ...subfiles];
+}
+function getFileExt(file) {
+  return (0, import_path4.extname)(file).replace(/\./g, "");
+}
+
+// libs/tracker/run/src/lib/get-git-commit.ts
+var import_date_fns3 = require("date-fns");
+var import_git_last_commit = require("git-last-commit");
+async function getGitCommit() {
+  const commit = await getLastCommitAsPromise();
+  return {
+    hash: commit.hash,
+    timestamp: formatDate(getGitDate(commit.committedOn))
+  };
+}
+function getLastCommitAsPromise() {
+  return new Promise((resolve4, reject) => {
+    (0, import_git_last_commit.getLastCommit)((err, commit) => {
+      if (err) {
+        reject(err);
+      }
+      resolve4(commit);
+    });
+  });
+}
+function formatDate(date) {
+  return (0, import_date_fns3.format)(date, "yyyy-MM-dd-HH-mm-ss-SSS");
+}
+function getGitDate(date) {
+  return new Date(+date * 1e3);
+}
+
+// libs/tracker/run/src/lib/process-config.ts
+async function processConfig(config, rootDirectory) {
+  console.log(`Starting...`);
+  const categoryResults = Object.entries(config.categories).map(
+    ([name, category]) => processCategory(
+      rootDirectory,
+      { ...category, name },
+      config.ignorePatterns || []
+    )
+  );
+  const commit = await getGitCommit();
+  return {
+    timestamp: commit.timestamp,
+    hash: commit.hash,
+    categories: categoryResults
+  };
+}
+
+// libs/tracker/run/src/lib/get-data.ts
+var import_fs7 = require("fs");
+
+// libs/tracker/run/src/lib/get-data-filepath.ts
+var import_path5 = require("path");
+function getDataFilePath(localRootDir, outputDir) {
+  return (0, import_path5.resolve)((0, import_path5.join)(localRootDir, outputDir, "data.json"));
+}
+
+// libs/tracker/run/src/lib/get-data.ts
+function getData(localRootDir, outputDir) {
+  const outputPath = getDataFilePath(localRootDir, outputDir);
+  let contents = "";
+  if ((0, import_fs7.existsSync)(outputPath)) {
+    contents = (0, import_fs7.readFileSync)(outputPath).toString("utf-8");
+  }
+  return contents === "" ? [] : JSON.parse(contents);
+}
+
+// libs/tracker/run/src/lib/save-results.ts
+var import_fs8 = require("fs");
+function saveResults(localRootDir, outputDir, results) {
+  console.log("Outputting file");
+  const output = getData(localRootDir, outputDir);
+  if (!Array.isArray(output)) {
+    console.error("Invalid output file format");
+  }
+  output.push(results);
+  const outputPath = getDataFilePath(localRootDir, outputDir);
+  const outputText = JSON.stringify(output, null, 2);
+  (0, import_fs8.writeFileSync)(outputPath, outputText);
+  console.log(`Output written to: ${outputPath}`);
+}
+
+// libs/tracker/run/src/lib/run.ts
+var trackerRunCommand = {
+  command: "run",
+  describe: "Run the tracker",
+  aliases: [],
+  builder: {
+    // root: Flags.string({ char: 'r', description: 'root dir of the project' }),
+    // config: Flags.string({ char: 'c', description: 'path to config file' }),
+  },
+  handler: run4
+};
+async function run4(args) {
+  const localRootDir = getRootDir(global.process.cwd());
+  const rootDirectory = args.root ? (0, import_path6.resolve)(args.root) : localRootDir;
+  const config = readConfig(localRootDir, args.config);
+  const results = await processConfig(config, rootDirectory);
+  saveResults(localRootDir, config.outputDir, results);
+}
+
+// apps/cli/src/lib/create-group-command.ts
+function createGroupCommand(group, description, subCommand, subCommandDescription, aliases, commands, errorMessage) {
+  const cmd = {
+    command: `${group} <${subCommand}>`,
+    describe: description,
+    aliases,
+    positional: {
+      type: {
+        type: "string",
+        demandOption: true,
+        describe: subCommandDescription
+      }
+    },
+    builder: (yargs2) => {
+      return yargs2.command(commands);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handler: (args) => {
+      console.log(`${errorMessage} (${args[subCommand]})`);
+    }
+  };
+  return cmd;
+}
+
+// libs/nes/init/src/lib/init.ts
+var import_prompts2 = require("@inquirer/prompts");
+
+// libs/nes/init/src/lib/verify-project-type.ts
+function verifyProjectType() {
+  const types = getProjectTypes();
+  let valid = true;
+  let error = void 0;
+  if (types.length === 0) {
+    valid = false;
+    error = "Unable to recognize a supported project type.";
+  }
+  return {
+    types,
+    valid,
+    error
+  };
+}
+
+// libs/nes/init/src/lib/get-release-trains.ts
+var import_core = require("@apollo/client/core");
+async function getReleaseTrains(accessToken, types) {
+  const client = new import_core.ApolloClient({
+    cache: new import_core.InMemoryCache(),
+    uri: "https://api.nes.herodevs.com/graphql"
+  });
+  try {
+    const queryResult = await client.query({
+      query: import_core.gql`
+        query RT($input: LicensingReleaseTrainsInput) {
+          licensing {
+            releaseTrains(input: $input) {
+              results {
+                key
+                name
+                products {
+                  id
+                  key
+                  name
+                }
+                entries {
+                  packageVersion {
+                    id
+                    name
+                    fqns
+                    origination {
+                      name
+                      type
+                      version
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      `,
+      variables: { input: { tenantId: 1e3, byToken: accessToken } }
+    });
+    const results = queryResult.data?.licensing?.releaseTrains?.results;
+    if (!results) {
+      throw new Error(`Error getting release trains`);
+    }
+    return results;
+  } catch (error) {
+    throw new Error(`Error getting release trains`);
+  }
+}
+
+// libs/nes/init/src/lib/get-product-choices.ts
+async function getProductChoices(accessToken, types) {
+  const releaseTrains = await getReleaseTrains(accessToken, types);
+  return releaseTrains.map((rt) => ({
+    name: rt.name,
+    value: rt
+  })).sort(sortByName);
+}
+
+// libs/nes/init/src/lib/get-package-choices.ts
+function getPackageChoices(releaseTrain) {
+  return releaseTrain.entries.map((e) => ({
+    name: e.packageVersion.origination?.name || e.packageVersion.name,
+    value: e
+  })).sort(sortByName);
+}
+
+// libs/nes/init/src/lib/npm/configure-npm-project.ts
+var import_fs9 = require("fs");
+var path2 = require("path");
+function configureNpmProject(accessToken, packages) {
+  updatePackageJson(packages);
+  updateNpmrc(accessToken);
+}
+function updatePackageJson(packages) {
+  const packageJsonPath = path2.join(process.cwd(), "package.json");
+  const packageJsonContents = (0, import_fs9.readFileSync)(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonContents);
+  const pkgUpdates = packages.map((p) => ({
+    key: p.packageVersion.origination?.name || p.packageVersion.name,
+    value: p.packageVersion.fqns
+  })).reduce(
+    (acc, cur) => {
+      if (packageJson.devDependencies?.[cur.key]) {
+        acc.devDeps[cur.key] = `npm:${cur.value}`;
+      } else if (packageJson.peerDependencies?.[cur.key]) {
+        acc.peerDeps[cur.key] = `npm:${cur.value}`;
+      } else {
+        acc.deps[cur.key] = `npm:${cur.value}`;
+      }
+      acc.overrides[cur.key] = { ".": `npm:${cur.value}` };
+      return acc;
+    },
+    { deps: {}, devDeps: {}, peerDeps: {}, overrides: {} }
+  );
+  packageJson.dependencies = {
+    ...packageJson.dependencies || {},
+    ...pkgUpdates.deps
+  };
+  packageJson.devDependencies = {
+    ...packageJson.devDependencies || {},
+    ...pkgUpdates.devDeps
+  };
+  packageJson.peerDependencies = {
+    ...packageJson.peerDependencies || {},
+    ...pkgUpdates.peerDeps
+  };
+  packageJson.overrides = {
+    ...packageJson.overrides || {},
+    ...pkgUpdates.overrides
+  };
+  (0, import_fs9.writeFileSync)(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+function updateNpmrc(accessToken) {
+  const npmrcPath = path2.join(process.cwd(), ".npmrc");
+  let npmrcContents = "";
+  if ((0, import_fs9.existsSync)(npmrcPath)) {
+    npmrcContents = (0, import_fs9.readFileSync)(npmrcPath, "utf8");
+  }
+  if (npmrcContents.includes(`@neverendingsupport:registry`)) {
+    return;
+  }
+  const updatedContents = npmrcContents + `
+
+@neverendingsupport:registry=https://registry.nes.herodevs.com/npm/pkg/
+//registry.nes.herodevs.com/npm/pkg/:_authToken="${accessToken}"`;
+  (0, import_fs9.writeFileSync)(npmrcPath, updatedContents);
+}
+
+// libs/nes/init/src/lib/configure-project.ts
+function configureProject(accessToken, projectTypes, packages) {
+  if (projectTypes.includes("npm")) {
+    configureNpmProject(accessToken, packages);
+  }
+}
+
+// libs/nes/init/src/lib/init.ts
+var ora = __toESM(require("ora"));
+var nesInitCommand = {
+  command: "init",
+  describe: "Initialize the NES project",
+  aliases: [],
+  builder: {},
+  handler: run5
+};
+async function run5(args) {
+  const spinner = ora();
+  const projectType = verifyProjectType();
+  if (!projectType.valid) {
+    console.error(projectType.error);
+    return;
+  }
+  if (!await (0, import_prompts2.confirm)({
+    message: "Before initializing, please commit all changes. Continue?"
+  })) {
+    return;
+  }
+  const accessToken = await (0, import_prompts2.password)({
+    message: "Enter access token",
+    mask: "*"
+  });
+  spinner.start("loading your products");
+  const productList = await getProductChoices(accessToken, projectType.types);
+  spinner.stop();
+  const releaseTrain = await (0, import_prompts2.select)({
+    message: "select a product",
+    choices: productList,
+    pageSize: productList.length
+    // no scrolling
+  });
+  const packageList = getPackageChoices(releaseTrain).map((p) => ({
+    ...p,
+    checked: true
+  }));
+  const packages = await (0, import_prompts2.checkbox)({
+    message: `select the package(s)`,
+    choices: packageList,
+    loop: false,
+    pageSize: packageList.length
+    // no scrolling
+  });
+  console.log("configuring your project...");
+  configureProject(accessToken, projectType.types, packages);
+  console.log("Your project is now configured to access your NES product");
+}
+
+// apps/cli/src/lib/get-commands.ts
+function getCommands() {
+  const nesCommand = createGroupCommand(
+    "nes",
+    "",
+    "command",
+    "nes command",
+    [],
+    [nesInitCommand],
+    "Invalid nes command"
+  );
+  const reportCommand = createGroupCommand(
+    "report",
+    "",
+    "type",
+    "type of report",
+    "r",
+    [reportCommittersCommand, reportDiagnosticsCommand],
+    "Invalid report type"
+  );
+  const trackerCommand = createGroupCommand(
+    "tracker",
+    "",
+    "command",
+    "tracker command",
+    [],
+    [trackerInitCommand, trackerRunCommand],
+    "Invalid tracker command"
+  );
+  return [nesCommand, reportCommand, trackerCommand];
+}
+
+// apps/cli/src/lib/ensure-version.ts
+var getJson = __toESM(require("get-json"));
+
+// apps/cli/src/lib/log-colors.ts
+function color(color2) {
+  return (...args) => {
+    return `${color2}${args.join(
+      ` ${color2}`
+      /*reset color for nested color*/
+    )}${"\x1B[0m" /* Reset */}`;
+  };
+}
+
+// apps/cli/src/lib/ensure-version.ts
+var red = color("\x1B[31m" /* FgRed */);
+var yellow = color("\x1B[33m" /* FgYellow */);
+async function getLatestVersion(pkgName) {
+  return getJson(`https://registry.npmjs.org/${pkgName}`).then(
+    (packageData) => {
+      return packageData["dist-tags"].latest;
+    }
+  );
+}
+async function isVersionUpToDate(packageName, packageVersion, quietIfSuccessful = false) {
+  if (packageVersion === "0.0.0") {
+    return true;
+  }
+  const latestVersion = await getLatestVersion(packageName);
+  if (latestVersion === packageVersion) {
+    if (!quietIfSuccessful) {
+      console.log(`${packageName}@${latestVersion} is up to date`);
+    }
+    return true;
+  }
+  console.log(
+    `${yellow(
+      "Your version:",
+      red(`${packageName}@${packageVersion}`),
+      `is not up to date`
+    )}`
+  );
+  console.log(
+    `${yellow("Latest version:", red(`${packageName}@${latestVersion}...`))}`
+  );
+  return false;
+}
+async function ensureVersionIsUpToDate(packageName, packageVersion) {
+  const versionUpToDate = await isVersionUpToDate(packageName, packageVersion);
+  if (!versionUpToDate) {
+    console.log(
+      [
+        `
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+`,
+        `${red(`ERROR:`)} Did not run command.
+
+`,
+        ` - Rerun your command with the ${yellow(
+          "@latest"
+        )} tag to ensure correct output:
+
+
+`,
+        `	${yellow(`npx ${packageName}@latest`)}
+`,
+        `
+
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+`
+      ].join(" ")
+    );
+    return process.exit(1);
+  }
+}
+
+// apps/cli/src/lib/cli.ts
+function cli() {
+  const commands = getCommands();
+  const pkg = require_package();
+  const packageName = pkg.name;
+  const packageVersion = pkg.version;
+  yargs.scriptName(packageName).usage("Usage: $0 <command> [options]").middleware(() => ensureVersionIsUpToDate(packageName, packageVersion)).command(commands).parse((0, import_helpers.hideBin)(process.argv));
+}
+
+// apps/cli/src/main.ts
+cli();