@leverege/build-tools 2.56.2 → 2.57.1

package/.har/config.json

@@ -0,0 +1,11 @@
+{
+  "protected-branches": [
+    "development",
+    "main"
+  ],
+  "npm-scripts": [
+    "lint",
+    "test"
+  ],
+  "ignore-packages": []
+}

package/.har/pre-commit

@@ -0,0 +1 @@
+hook-and-release

package/.har/pre-push

@@ -0,0 +1 @@
+hook-and-release

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leverege/build-tools",
-  "version": "2.56.2",
+  "version": "2.57.1",
   "description": "A collection of build / support tools for Leverege developers",
   "main": "index.js",
   "repository": {
@@ -10,7 +10,7 @@
   "scripts": {
     "clean": "rm -rf lib",
     "lint": "find ./src -name \\*.\\*js | xargs npx eslint --report-unused-disable-directives",
-    "prepare": "npx husky",
+    "prepare": "[ $SKIP_PREPARE ] && exit 0 || hook-and-release",
     "test": "echo \"no tests specified\" && exit 0"
   },
   "bin": {
@@ -35,6 +35,7 @@
     "helmup": "src/helmup.sh",
     "helminit": "src/helmup.sh",
     "helmwhat": "src/helmup.sh",
+    "hook-and-release": "src/hook-and-release.mjs",
     "k8cryo": "src/k8cryo.sh",
     "k8scale": "src/k8scale.sh",
     "k8thaw": "src/k8cryo.sh",
@@ -77,11 +78,10 @@
     "readline-sync": "^1.4.10",
     "semver": "^7.6.3",
     "simple-git": "^3.27.0",
-    "zx": "^8.2.1"
+    "zx": "^8.2.2"
   },
   "devDependencies": {
     "@leverege/eslint-config-leverege": "^5.0.1",
-    "husky": "^9.1.6",
     "npm": "^10.9.0"
   }
 }

package/src/Docker.mjs

@@ -45,6 +45,7 @@ RUN apk --no-cache add openssh-client && \
 {{preInstallPluginfile}}
 
 # Removed --ignore-scripts from npm ci because it was causing issues with python native build
+ENV SKIP_PREPARE=true
 RUN npm ci --only=production --no-optional {{npmlogging}} && \
     rm -f /usr/src/app/.npmrc /root/.ssh/*
 
@@ -153,8 +154,8 @@ images:
 const defaultSettings = {
   apkadds : '',
   date : getDateTimestamp(),
-  nodeimage : 'iron-alpine',
-  npmlogging : '--silent',
+  nodeimage : process.env.USE_NODEJS_22 ? 'jod-alpine' : 'iron-alpine',
+  npmlogging : process.env.VERBOSE_NPM_LOGGING ? '--ddd' : '--silent',
   pluginfile : '# NO PLUGIN',
   preInstallPluginfile : '# NO PRE-INSTALL PLUGIN',
   regvers : 'package.version',

package/src/Utils.mjs

@@ -116,26 +116,29 @@ export const getGcpSecret = async ( gcpProject, secretName, opts ) => {
   }
 }
 
-export const getGitRootDirectory = async () => {
+const runGitCommand = async ( cmd, debugLabel ) => {
   try {
-    const gitRoot = await shellCmd( 'git rev-parse --show-toplevel' )
-    debug( { gitRoot }, '<==getGitRootDirectory' )
-    return gitRoot
+    const result = await shellCmd( cmd )
+    debug( { result }, `<==${debugLabel}` )
+    return result
   } catch ( error ) {
-    debug( { error }, '<==getGitRootDirectory' )
-    throw error
+    debug( { error }, chalk.red( `***ERROR git failed [${cmd}]` ) )
+    return undefined
   }
 }
 
-export const getGitUpstream = async () => {
-  let branch
+export const getGitBranch = async () => runGitCommand( 'git rev-parse --abbrev-ref HEAD', 'getGitCurrentBranch' )
+export const getGitDiff = async opts => runGitCommand( `git diff ${opts}`, 'getGitDiff' )
+export const getGitHooksPath = async () => runGitCommand( 'git config --get core.hooksPath', 'getGitHooksPath' )
+export const setGitHooksPath = async hookPath => runGitCommand( `git config core.hooksPath ${hookPath}`, 'setGitHooksPath' )
+export const getGitRootDirectory = async () => runGitCommand( 'git rev-parse --show-toplevel', 'getGitRootDirectory' )
+export const getGitBranchAndUpstream = async () => {
+  const branch = await getGitBranch() ?? 'detached'
+  let upstream = 'no-upstream'
   try {
-    branch = await shellCmd( 'git rev-parse --abbrev-ref HEAD' )
-    const upstream = await shellCmd( `git rev-parse --abbrev-ref ${branch}@{u}` )
-    return { branch, upstream }
-  } catch ( err ) {
-    return { branch, upstream : undefined }
-  }
+    upstream = await runGitCommand( `git rev-parse --abbrev-ref ${branch}@{u}`, 'getGitUpstream' ) ?? 'no-upstream'
+  } catch ( error ) {}
+  return { branch, upstream }
 }
 
 export const gitRepoIsDirty = async () => {
@@ -387,7 +390,8 @@ export const getRepositoryDescr = async () => {
   const currentDir = process.cwd()
   const workingDir = process.env.PWD
   const gitRoot = await getGitRootDirectory()
-  const { branch : gitBranch, upstream : gitUpstream } = await getGitUpstream()
+  const gitHooksPath = await getGitHooksPath()
+  const { branch : gitBranch, upstream : gitUpstream } = await getGitBranchAndUpstream()
   const subPkgs = await glob( `${gitRoot}/packages/**/package.json`, { ignore : '/**/node_modules/**' } )
   const helmChart = await parseHelmChart()
   const isMonoRepo = subPkgs?.length > 0
@@ -403,6 +407,7 @@ export const getRepositoryDescr = async () => {
     currentDir,
     workingDir,
     gitBranch,
+    gitHooksPath,
     gitRoot,
     gitUpstream,
     helmChart,

package/src/docker-to-registry.mjs

@@ -11,7 +11,7 @@ import {
   debug, log,
   errorExit,
   analyzeRepository,
-  getGitUpstream,
+  getGitBranchAndUpstream,
   gitRepoIsDirty,
   proceed,
   shellCmd } from './Utils.mjs'
@@ -234,7 +234,7 @@ if ( imageVersion !== packageVersion ) {
   }
 }
 
-const repoInfo = await getGitUpstream()
+const repoInfo = await getGitBranchAndUpstream()
 
 if ( willGitTag && !repoInfo.upstream ) {
   log( `

package/src/helmup.sh

@@ -178,6 +178,7 @@ function makeUniformBucketWithCors() {
     gsutil mb -l $GCE_REGION -p $GCP_PROJECT_ID $BUCKET_NAME &> /dev/null
     [ "$?" -ne 0 ] && errorExit "failed to create the bucket: `color y $BUCKET_NAME`"
   fi
+  gcloud storage buckets update $BUCKET_NAME --uniform-bucket-level-access
   CORS_JSON_FILE="$(build-tools --reporoot)/src/helmup-cors-for-buckets.json"
   printf "  Applying CORS policy\n"
   gsutil cors set $CORS_JSON_FILE $BUCKET_NAME &> /dev/null

package/src/hook-and-release/CLIParser.mjs

@@ -0,0 +1,23 @@
+import commandLineArgs from 'command-line-args'
+import commandLineUsage from 'command-line-usage'
+
+import { log } from '../Utils.mjs'
+
+const parseCLIArgs = ( optionList, sections ) => {
+  const cliArgs = commandLineArgs( optionList, { camelCase : true, partial : true } )
+
+  /* eslint-disable no-underscore-dangle */
+  if ( cliArgs._unknown ) {
+    throw new Error( `Unknown command line options: ${cliArgs._unknown.join( ', ' )}` )
+  }
+  /* eslint-enable no-underscore-dangle */
+
+  if ( cliArgs.help ) {
+    log( commandLineUsage( sections ) )
+    process.exit( 0 )
+  }
+
+  return cliArgs
+}
+
+export default parseCLIArgs

package/src/hook-and-release/Config.mjs

@@ -0,0 +1,249 @@
+import fs from 'node:fs'
+
+import chalk from 'chalk'
+
+import {
+  debug,
+  enableDebug,
+  errorExit,
+  getRepositoryDescr,
+  log,
+  parseJsonFile,
+  setGitHooksPath,
+  shellCmd,
+  warning,
+} from '../Utils.mjs'
+
+import parseCLIArgs from './CLIParser.mjs'
+
+const cliOptionList = [
+  {
+    name : 'init',
+    type : Boolean,
+    default : false,
+    description : '{green bootstraps the repo .har directory and adds appropriate git hook}',
+  },
+  {
+    name : 'debug',
+    type : Boolean,
+    default : false,
+    description : '{yellow enables verbose debugging}',
+  },
+  {
+    name : 'help',
+    type : Boolean,
+    default : false,
+    description : '{green display this help screen}',
+  },
+]
+
+const cliSections = [
+  {
+    header : 'Leverege Hook and Release (HAR) Script',
+    content : `{green HAR is a replacement for the Husky git hook manager - it is designed to
+handle git hooks in standard git repositories as well as git monorepos. It
+connects into a repository's git hook system after a repo is cloned. The hook
+connection is made during the {yellow.bold npm install} phase, which will execute the
+{yellow.bold npm prepare} script as defined in the package.json scripts section:
+
+  {yellow.bold "scripts": {
+    ...
+    "prepare": "hook-and-release",
+    ...
+  }
+
+The hook-and-release script can be invoked directly from the command line,
+typically for first-time initialization, or from the git hook scripts located
+in the .har subdirectory in the root of a repository. Running with the {yellow.bold --init}
+command line switch will create the .har subdirectory at the repo root with a
+config.json file and two standard hook scripts, pre-commit and pre-push:
+
+  {yellow.bold .har
+  ├── config.json
+  ├── pre-commit
+  └── pre-push}
+}`
+  },
+  {
+    header : 'Options',
+    optionList : cliOptionList,
+  },
+  {
+    header : 'Configuration File and Hook Scripts',
+    content : [
+      `{bold .har/config.json}   {green controls branch, script and package config
+{white.bold protected-branches} list of branch names to protect
+{white.bold npm-scripts}        list of npm scripts to run on protected branches
+{white.bold ignore-packages}    list of monorepo packages to ignore
+
+{white.bold Example config.json}
+\\{
+  "protected-branches": [
+    "development",
+    "main",
+  ],
+  "npm-scripts": [
+    "lint",
+    "test"
+  ],
+  "ignore-packages": [
+    "legacy-*"
+  ]
+\\}
+
+{white.bold Example pre-commit script file contents}
+
+  hook-and-release --debug
+
+which tell HAR to run with debugging enabled. This will print out copious
+amounts of information and prevents the git command from succeeding, so
+it's more like a debug with dry-run. Removing the {yellow.bold --debug} will
+allow everything to run normally.
+}`
+    ]
+  },
+]
+
+/* eslint-disable security/detect-non-literal-fs-filename */
+export default class Config {
+  constructor( options = {} ) {
+    try {
+      this.cliArgs = parseCLIArgs( cliOptionList, cliSections )
+
+      if ( this.cliArgs.debug ) {
+        enableDebug()
+      }
+    } catch ( error ) {
+      log( chalk.red( `\n***ERROR: ${error.message}` ) )
+      process.exit( 1 )
+    }
+  }
+
+  async bootstrapHookAndRelease() {
+    const repoDescr = await getRepositoryDescr()
+    this.gitRoot = repoDescr.gitRoot
+    this.gitBranch = repoDescr.gitBranch
+    this.gitHooksPath = repoDescr.gitHooksPath
+    this.isMonoRepo = repoDescr.isMonoRepo
+
+    const harHook = '.har'
+    this.harDir = `${this.gitRoot}/${harHook}`
+
+    if ( this.gitHooksPath !== harHook ) {
+      await setGitHooksPath( harHook )
+    }
+
+    if ( this.cliArgs.init ) {
+      await this.initializeConfiguration( this.harDir )
+    }
+
+    // Start with the basics, is there a root har directory?
+    if ( !fs.existsSync( this.harDir ) ) {
+      const missingHarDir = `
+  The required .har configuration directory is missing from this repository. Try running:
+
+       hook-and-release --init
+
+  which will populate the ${this.harDir} directory.`
+      errorExit( missingHarDir )
+    }
+
+    const harConfigFile = `${this.harDir}/config.json`
+    if ( !fs.existsSync( harConfigFile ) ) {
+      const missingHarConfig = `
+  The required .har/config.json file is missing from this repository which implies
+  the init phase failed. Try removing the .har directory and rerunning:
+
+       hook-and-release --init`
+      errorExit( missingHarConfig )
+    }
+
+    let jsonConfig
+    try {
+      jsonConfig = await parseJsonFile( harConfigFile )
+    } catch ( error ) {
+      errorExit( `
+  There appears to be a syntax error in the har config file:
+
+    ${harConfigFile}
+
+    ${error}
+
+  correct the JSON syntax and try again` )
+
+      return undefined
+    }
+
+    this.jsonConfig = jsonConfig
+    this.protectedBranches = jsonConfig['protected-branches'] || [ 'main', 'development' ]
+    this.ignoredPackages = jsonConfig['ignore-packages'] || ''
+    this.npmScripts = jsonConfig['npm-scripts'] || [ 'lint', 'test' ]
+    return this
+  }
+
+  isBranchProtected() {
+    const branchName = this.gitBranch
+    const protectedBranch = this.protectedBranches.some( ( pattern ) => {
+      // convert wildcard pattern to a regular expression
+      const regex = new RegExp( `^${pattern.replace( /\*/g, '.*' )}$` ) // eslint-disable-line security/detect-non-literal-regexp
+      return regex.test( branchName )
+    } )
+    debug( { branchName, protectedBranch }, '<==harConfig isBranchProtected' )
+    return protectedBranch
+  }
+
+  // this could be made more generic but the initial config is dirt simple
+  async initializeConfiguration( harDir ) {
+    if ( fs.existsSync( harDir ) ) {
+      const harConfigExists = `The hook-and-release configuration directory already exists - skipping --init
+
+      `
+      warning( harConfigExists )
+      return
+    }
+    fs.mkdirSync( harDir, { recursive : true } )
+
+    const CONFIG_CONTENT = {
+      'protected-branches' : [ 'development', 'main' ],
+      'npm-scripts' : [ 'lint', 'test' ],
+      'ignore-packages' : []
+    }
+    fs.writeFileSync( `${harDir}/config.json`, JSON.stringify( CONFIG_CONTENT, null, 2 ), 'utf8' )
+
+    const makeHarHookScript = async ( harScript ) => {
+      const SCRIPT_CONTENT = 'hook-and-release'
+
+      fs.writeFileSync( harScript, SCRIPT_CONTENT, 'utf8' )
+      fs.chmodSync( harScript, 0o750 )
+    }
+
+    makeHarHookScript( `${harDir}/pre-commit` )
+    makeHarHookScript( `${harDir}/pre-push` )
+  }
+
+  async runNpmScripts( runDirectories = [] ) {
+    for ( const runDirectory of runDirectories ) { // eslint-disable-line no-restricted-syntax
+      const scripts = this.npmScripts
+
+      // for each script run sequentially
+      for ( const script of scripts ) { // eslint-disable-line no-restricted-syntax
+        const cmd = `npm run ${script}`
+        log( `hook-and-release in ${chalk.green( runDirectory )} => ${chalk.green( cmd )}` )
+        if ( !this.cliArgs.debug ) {
+          try {
+            await shellCmd( cmd, { cwd : runDirectory, stdio : 'inherit' } ) // eslint-disable-line no-await-in-loop
+          } catch ( err ) {
+            errorExit( err )
+          }
+        }
+      }
+    }
+  }
+
+  // Static async factory method to initialize the Config object and run async setup
+  static async create( options = {} ) {
+    const config = new Config( options )
+    await config.bootstrapHookAndRelease()
+    return config
+  }
+}

package/src/hook-and-release/index.mjs

@@ -0,0 +1,3 @@
+import Config from './Config.mjs'
+
+export default Config

package/src/hook-and-release.mjs

@@ -1,161 +1,64 @@
 #!/usr/bin/env node
 
-import fs from 'node:fs'
 import path from 'node:path'
 
-import chalk from 'chalk'
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import SimpleGit from 'simple-git'
+import { debug, getGitDiff, } from './Utils.mjs'
 
-import {
-  condir,
-  debug,
-  enableDebug,
-  getRepositoryDescr,
-  log,
-  shellCmd,
-} from './Utils.mjs'
+import Config from './hook-and-release/index.mjs'
 
-const git = new SimpleGit()
-const repoDescr = await getRepositoryDescr()
+const harConfig = await Config.create()
+debug( { harConfig }, '<==hook-and-release config object' )
 
-debug( { repoDescr }, '--------LOCAL UNLEASH-------' )
+// Config.create() is the only thing that needs to run during npm install
+if ( process.env.npm_lifecycle_event === 'prepare' ) { process.exit( 0 ) }
 
-const hookAndReleaseOptions = [
-  {
-    name : 'init',
-    type : Boolean,
-    default : false,
-    description : '{green bootstraps the repo .har directory and adds appropriate git hook}',
-  },
-  {
-    name : 'debug',
-    type : Boolean,
-    default : false,
-    description : '{yellow enables verbose debugging}',
-  },
-  {
-    name : 'help',
-    type : Boolean,
-    default : false,
-    description : '{green display this help screen}',
-  },
-]
+// if this branch isn't under protection then we're done
+if ( !harConfig.isBranchProtected() ) { process.exit( 0 ) }
 
-const sections = [
-  {
-    header : 'Leverege Hook and Release Script',
-    content : '{green This tool help...}',
-  },
-  {
-    header : 'Options',
-    optionList : hookAndReleaseOptions,
-  },
-]
-
-const args = commandLineArgs( hookAndReleaseOptions, { camelCase : true, partial : true } )
-const usage = commandLineUsage( sections )
-
-if ( args.debug ) {
-  enableDebug()
-}
-
-if ( args.help ) {
-  log( usage )
-  process.exit( 0 )
-}
-
-/* eslint-disable no-underscore-dangle */
-if ( args._unknown ) {
-  log( usage )
-    log( `\nUnrecognized argument [${chalk.bold.red( args._unknown )}]\n` )
-    process.exit( 1 )
-}
-/* eslint-enable no-underscore-dangle */
-
-if ( args.init ) {
-  const harDir = `${repoDescr.gitRoot}/.har`
-  if ( fs.existsSync( harDir ) ) {
-    log( `this repo already has ${harDir}` )
-    process.exit( 1 )
+// TODO: maybe move getRunDirectories into the har Config class too?
+const getRunDirectories = async () => {
+  // non-mono means we just run once from the root of the repo
+  if ( !harConfig.isMonoRepo ) {
+    return [ process.cwd() ]
   }
 
-  fs.mkdirSync( harDir )
-  await git.addConfig( 'core.hookspath', '.har' )
-  process.exit( 0 )
-}
-
-const getCurrentBranchName = async () => {
-  const branchInfo = await git.branch()
-
-  // first check to see if there are no branches - new repo?
-  if ( Object.keys( branchInfo.branches ).length === 0 ) { return '' }
-
-  return Object
-    .entries( branchInfo.branches )
-    .find( ( [ name, info ] ) => ( info.current ) )[0]
-}
-
-const isProtected = async () => {
-  const theBranch = await getCurrentBranchName()
-
-  const protectedBranches = [ 'main', 'master', 'development' ]
-  const additionalProtectedBranches = [ ...process.argv.slice( 2 ) ]
-
-  // Check if the current branch starts with any of the additional
-  // protected branch name
-  let matchesAdditionalBranch = false
-  for ( let i = 0; i < additionalProtectedBranches.length; i++ ) {
-    matchesAdditionalBranch = matchesAdditionalBranch ||
-      theBranch.startsWith( additionalProtectedBranches[i] )
-  }
-
-  return protectedBranches.includes( theBranch ) || matchesAdditionalBranch
-}
-
-// Identify the package directory based on staged files
-const getPackageDirectory = async () => {
-  const gitDiff = await git.diff( [ '--name-only', '--cached' ] )
+  // otherwise get staged mods from git and parse out the package names
+  const gitDiff = await getGitDiff( '--name-only --cached' )
   const stagedFiles = gitDiff.split( '\n' )
   const packageDirs = new Set()
 
-  // Loop through staged files and extract package directories
+  // loop through staged files and extract package directories
   stagedFiles.forEach( ( file ) => {
     const parts = file.split( path.sep ) // Split path to identify package
     if ( parts.length > 1 && parts[0] === 'packages' ) {
       const packageDir = parts[1]
-      packageDirs.add( packageDir )
+
+      // check if the package should be ignored before adding it to the Set
+      const shouldIgnore = harConfig.ignoredPackages.some( ( ignoredPattern ) => {
+        // convert an entry like legacy-* into a regex legacy-.*
+        const regex = new RegExp( ignoredPattern.replace( '*', '.*' ) ) // eslint-disable-line security/detect-non-literal-regexp
+        return regex.test( packageDir )
+      } )
+
+      if ( shouldIgnore ) {
+        debug( { packageDir }, '<==ignoring based on config' )
+      } else {
+        packageDirs.add( packageDir )
+      }
     }
   } )
 
   const packageDirsArray = Array.from( packageDirs )
-  debug( { stagedFiles, packageDirsArray }, '<==unleash: getPackageDirectory' )
-  return packageDirsArray
-}
+  const packageDirsWithPath = packageDirsArray.map( ( packageDir ) => {
+    return path.join( process.cwd(), 'packages', packageDir )
+  } )
 
-const npmRunner = async ( script, packageDir ) => {
-  try {
-    const cmd = `npm run ${script}`
-    const results = await shellCmd( cmd, { cwd : path.join( process.cwd(), 'packages', packageDir ), stdio : 'inherit' } )
-    return results
-  } catch ( err ) {
-    process.exit( 1 )
-  }
-  return undefined
+  debug( { stagedFiles, packageDirsArray, packageDirsWithPath }, '<==unleash: getPackageDirectory' )
+  return packageDirsWithPath
 }
 
-( async () => {
-  if ( await isProtected() ) {
-    const packageDirs = await getPackageDirectory()
-    for ( let pi = 0; pi < packageDirs.length; pi++ ) {
-      const packageDir = packageDirs[pi]
-      const script = [ 'test', 'lint' ]
-      for ( let i = 0; i < script.length; i++ ) {
-        await npmRunner( script[i], packageDir ) // eslint-disable-line no-await-in-loop
-      }
-    }
-  } else {
-    process.exit( 0 )
-  }
-} )()
+const runDirectories = await getRunDirectories()
+await harConfig.runNpmScripts( runDirectories )
+
+// exit status of 1 in debug mode to prevent git from running
+process.exit( harConfig.cliArgs.debug ? 1 : 0 )

package/.husky/pre-commit

@@ -1 +0,0 @@
-unleash

package/.husky/pre-push

@@ -1 +0,0 @@
-unleash

package/registry-compass.yaml

@@ -1,20 +0,0 @@
-registry:
-  - root: us-docker.pkg.dev
-  - repositories:
-    - name: stack
-      charts:
-        - api-server
-        - authz-server
-        - emailer
-        - message-processor
-    - name: leverege
-      charts:
-        - pubsub-pulse
-        - pusher
-        - overdose
-    - name: cox-health
-      charts:
-        - actions-server
-        - analytics-server
-        - centrak-healthz
-        - centrak-ingestor

package/src/chart-compass.mjs

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-/*
- * chart-to-registry will...
- */
-import fs from 'node:fs'
-
-import chalk from 'chalk'
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import { lt as semverLt } from 'semver'
-import YAML from 'js-yaml'
-
-import {
-  condir,
-  debug,
-  errorExit,
-  log,
-  warning,
-  getGitRootDirectory,
-  parsePackageJson,
-  parseHelmChart,
-  shellCmd } from './Utils.mjs'
-
-const commandLineOptions = [ // Use commandLineOptions to tie into the Usage statements
-   
-  {
-    name : 'location',
-    type : String,
-    description : '{green the location of the artifact registry the chart will be pushed to (default us-docker.pkg.dev)}',
-  },
-  {
-    name : 'project',
-    type : String,
-    description : '{green the name of the google project containing the npmrc and slack config secrets (default leverege-registry)}',
-  },
-  {
-    name : 'repository',
-    type : String,
-    description : '{green the target repository to receive the pushed chart}',
-  },
-  {
-    name : 'dry-run',
-    type : Boolean,
-    description : '{yellow perform everything except the actual chart push}',
-  },
-  {
-    name : 'help',
-    type : Boolean,
-    description : '{green display this help screen}',
-  },
-   
-]
-
-const sections = [
-  {
-    header : 'Leverege Helm Chart Compass (for helmup)',
-    content : `{green This tool helps helmup navigate the helm charts stored in the
-artifact-registries.}`
-  },
-  { header : 'Options',
-    optionList : commandLineOptions,
-  },
-]
-
-const args = commandLineArgs( commandLineOptions, { camelCase : true, partial : true } )
-const usage = commandLineUsage( sections )
-
-if ( args.help ) {
-  log( usage )
-  process.exit( 0 )
-}
-
-/* eslint-disable no-underscore-dangle */
-if ( args._unknown ) {
-  log( usage )
-  log( `\nUnrecognized argument [${chalk.bold.red( args._unknown )}]\n` )
-  process.exit( 1 )
-}
-/* eslint-enable no-underscore-dangle */
-
-const minNodejsVersion = '18.0.0'
-if ( semverLt( process.version, minNodejsVersion ) ) {
-  errorExit( `\n***ERROR: must be running at least node ${minNodejsVersion}\n` )
-}
-
-// First of all, fail if we are not in a git repository
-let gitRoot
-try {
-  gitRoot = await getGitRootDirectory()
-} catch ( error ) {
-  errorExit( chalk.red.bold( error ), { errorCode : 5 } )
-}
-
-const chartCompass = YAML.load( fs.readFileSync( './registry-compass.yaml', 'utf8' ) )
-
-condir( { chartCompass }, '<==Navigation' )