@leverege/build-tools 2.102.0 → 2.104.0

package/src/repo-panopticon.mjs

@@ -0,0 +1,415 @@
+#!/usr/bin/env node
+/* eslint-disable security/detect-non-literal-fs-filename */
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { program } from 'commander'
+import chalk from 'chalk'
+import { glob } from 'glob'
+import ora from 'ora'
+import pLimit from 'p-limit'
+import simpleGit from 'simple-git'
+
+import { clear, enableDebug, log, parseJsonFile } from './Utils.mjs'
+
+// ---------- Symbols ----------
+
+const SYM_GOOD = chalk.green( '✔' )
+const SYM_BAD  = chalk.red( '✘' )
+
+// ---------- Checks ----------
+// Each check: { label: string, fn: ({ dir, pkg, isWorkspace }) => { value: string } }
+// Add new checks here — the table expands automatically.
+
+const CHECKS = [
+  {
+    label : 'cir',
+    fn    : ( { dir } ) => {
+      const cfgPath = path.join( dir, '.circleci', 'config.yml' )
+      if ( !fs.existsSync( cfgPath ) ) return { value : SYM_BAD }
+      try {
+        const content = fs.readFileSync( cfgPath, 'utf8' )
+        const match = content.match( /leverege\/circle-nodejs-ci@(\d+)\.\d+\.\d+/ )
+        if ( !match || parseInt( match[1], 10 ) === 0 ) return { value : chalk.hex( '#FFA500' )( 'L' ) }
+        const major = parseInt( match[1], 10 )
+        return { value : major === 1 ? chalk.yellow( '1' ) : chalk.green( `${major}` ) }
+      } catch {
+        return { value : chalk.hex( '#FFA500' )( 'L' ) }
+      }
+    },
+  },
+  {
+    label : 'ESM',
+    fn    : ( { pkg } ) => {
+      const ok = pkg?.type === 'module'
+      return { value : ok ? SYM_GOOD : SYM_BAD }
+    },
+  },
+  {
+    label : 'har',
+    fn    : ( { gitRoot } ) => {
+      const ok = fs.existsSync( path.join( gitRoot, '.har' ) )
+      return { value : ok ? SYM_GOOD : SYM_BAD }
+    },
+  },
+  {
+    label : 'lnt',
+    fn    : ( { dir, pkg, gitRoot } ) => {
+      if ( !pkg?.scripts?.lint ) return { value : SYM_BAD }
+      try {
+        // Prefer package-local node_modules; fall back to monorepo root (hoisted)
+        const local  = path.join( dir, 'node_modules', 'eslint', 'package.json' )
+        const hoisted = path.join( gitRoot, 'node_modules', 'eslint', 'package.json' )
+        const eslintPkg = JSON.parse( fs.readFileSync(
+          fs.existsSync( local ) ? local : hoisted, 'utf8'
+        ) )
+        const major = parseInt( eslintPkg.version.split( '.' )[0], 10 )
+        return { value : major <= 8 ? chalk.yellow( `${major}` ) : chalk.green( `${major}` ) }
+      } catch {
+        return { value : chalk.dim( '?' ) }
+      }
+    },
+  },
+  {
+    label : 'bbl',
+    fn    : ( { dir, pkg } ) => {
+      const configFiles = [ '.babelrc', '.babelrc.js', '.babelrc.json', 'babel.config.js', 'babel.config.json', 'babel.config.cjs' ]
+      const hasConfig   = configFiles.some( f => fs.existsSync( path.join( dir, f ) ) )
+      const allDeps     = { ...( pkg?.dependencies ?? {} ), ...( pkg?.devDependencies ?? {} ) }
+      const hasDep      = Object.keys( allDeps ).some( k => k.includes( 'babel' ) )
+      return { value : ( hasConfig || hasDep ) ? SYM_BAD : chalk.dim( '–' ) }
+    },
+  },
+]
+
+// ---------- Helpers ----------
+
+const ANSI_RE = /\x1B\[[0-9;]*m/g // eslint-disable-line no-control-regex
+
+function visLen( str ) {
+  return str.replace( ANSI_RE, '' ).length
+}
+
+function pad( str, width ) {
+  return str + ' '.repeat( Math.max( 0, width - visLen( str ) ) )
+}
+
+function center( str, width ) {
+  const gap = Math.max( 0, width - visLen( str ) )
+  const left = Math.floor( gap / 2 )
+  return ' '.repeat( left ) + str + ' '.repeat( gap - left )
+}
+
+const NONSEMVER = '!SEMVER'
+
+// Strict x.y.z only — pre-release and build metadata are flagged !SEMVER
+function parseVersion( raw ) {
+  if ( !raw ) return null
+  const v = raw.startsWith( 'v' ) ? raw : `v${raw}`
+  return /^v\d+\.\d+\.\d+$/.test( v ) ? v : NONSEMVER
+}
+
+function fmtPkgVer( ver ) {
+  if ( !ver ) return chalk.dim( '?' )
+  if ( ver === NONSEMVER ) return chalk.yellow( NONSEMVER )
+  return chalk.green( ver )
+}
+
+function fmtGitVer( gitVer, pkgVer ) {
+  if ( !gitVer ) return chalk.bgRed.white( 'UNTAGGD' )
+  if ( gitVer === NONSEMVER ) return chalk.yellow( NONSEMVER )
+  if ( gitVer === pkgVer ) return chalk.green( gitVer )
+  return chalk.yellow( gitVer )
+}
+
+function fmtScope( pkg ) {
+  const name = pkg?.name ?? ''
+  const match = name.match( /^(@[^/]+)/ )
+  if ( match ) return chalk.green( match[1].slice( 0, 4 ) )  // '@' + 3 chars: @leverege → @lev
+  if ( pkg?.private === true ) return chalk.yellow( 'PRVT' )
+  return chalk.bgRed.white( 'PUBL' )
+}
+
+// Extracts { repoName, group } from a directory path.
+// For workspace packages (gitRoot !== dir), group is the monorepo's org/name path
+// and repoName is the package's own directory name.
+// For root repos, group is the @xxx path component and repoName is relative to it.
+function repoLabel( dir, gitRoot ) {
+  const parts = dir.split( path.sep )
+  const atIdx = parts.findIndex( p => /^@\w+$/.test( p ) )
+
+  if ( gitRoot && gitRoot !== dir ) {
+    // Workspace package — group under the monorepo's label
+    const rootParts = gitRoot.split( path.sep )
+    const rootAtIdx = rootParts.findIndex( p => /^@\w+$/.test( p ) )
+    const group = rootAtIdx === -1 ?
+      path.basename( gitRoot ) :
+      rootParts.slice( rootAtIdx ).join( '/' )
+    return { repoName : path.basename( dir ), group }
+  }
+
+  if ( atIdx === -1 ) return { repoName : path.basename( dir ), group : null }
+  const group = parts[atIdx]
+  const repoName = parts.slice( atIdx + 1 ).join( '/' )
+  return { repoName, group }
+}
+
+// ---------- Per-repo ----------
+
+async function checkRepo( dir, { pull } ) {
+  if ( !fs.existsSync( path.join( dir, 'package.json' ) ) ) return null
+
+  let gitRoot
+  try {
+    gitRoot = ( await simpleGit( dir ).revparse( [ '--show-toplevel' ] ) ).trim()
+  } catch {
+    return null
+  }
+
+  const isWorkspace = gitRoot !== dir
+  const git = simpleGit( gitRoot )
+  const pkg = await parseJsonFile( path.join( dir, 'package.json' ) )
+
+  // Monorepo roots are represented by their workspace packages — skip the root itself
+  if ( !isWorkspace && pkg?.workspaces ) return null
+
+  const pkgVer = parseVersion( pkg?.version )
+
+  let syncOk = true
+  if ( isWorkspace ) {
+    try {
+      const relDir = path.relative( gitRoot, dir )
+      const status = await git.status( [ '--', relDir ] )
+      syncOk = status.files.length === 0
+    } catch {
+      syncOk = false
+    }
+  } else if ( pull ) {
+    try {
+      await git.pull()
+      await git.fetch( [ '--tags' ] )
+    } catch {
+      syncOk = false
+    }
+  }
+
+  let gitVer = null
+  if ( isWorkspace ) {
+    // Look for workspace-style tags: pkg-name/vX.Y.Z
+    const pkgBaseName = ( pkg?.name ?? path.basename( dir ) ).replace( /^@[^/]+\//, '' )
+    try {
+      const tagOutput = ( await git.raw( [ 'tag', '--list', `${pkgBaseName}/v*` ] ) ).trim()
+      if ( tagOutput ) {
+        const semverTags = tagOutput.split( '\n' )
+          .map( ( t ) => { const m = t.trim().match( /(?:^|\/)v(\d+\.\d+\.\d+)$/ ); return m ? m[1] : null } )
+          .filter( Boolean )
+        if ( semverTags.length ) {
+          semverTags.sort( ( a, b ) => {
+            const av = a.split( '.' ).map( Number )
+            const bv = b.split( '.' ).map( Number )
+            return ( bv[0] - av[0] ) || ( bv[1] - av[1] ) || ( bv[2] - av[2] )
+          } )
+          gitVer = `v${semverTags[0]}`
+        } else {
+          gitVer = NONSEMVER
+        }
+      }
+    } catch { /* no tags → null = UNTAGGD */ }
+  } else {
+    // git describe gives the nearest tag reachable from HEAD, matching original pkgck behavior
+    try {
+      const tag = ( await git.raw( [ 'describe', '--abbrev=0', '--tags' ] ) ).trim()
+      // Handles 'v1.2.3' and workspace-style 'pkg-name/v1.2.3'
+      const match = tag.match( /(?:^|\/)v(\d+\.\d+\.\d+)$/ )
+      gitVer = match ? `v${match[1]}` : NONSEMVER
+    } catch { /* no tags → null = UNTAGGD */ }
+  }
+
+  let needsPush = ''
+  if ( pkgVer && pkgVer !== NONSEMVER && gitVer === pkgVer ) {
+    try {
+      const pkgBaseName = ( pkg?.name ?? path.basename( dir ) ).replace( /^@[^/]+\//, '' )
+      const tagToCheck = isWorkspace ? `${pkgBaseName}/${pkgVer}` : pkgVer
+      const remote = await git.listRemote( [ '--tags', 'origin' ] )
+      if ( !remote.includes( tagToCheck ) ) needsPush = chalk.yellow( '!tags' )
+    } catch { /* ignore */ }
+  }
+
+  const isYarn   = fs.existsSync( path.join( gitRoot, 'yarn.lock' ) ) || fs.existsSync( path.join( gitRoot, '.yarn' ) )
+  const pkgMgr   = isYarn ? chalk.cyan( 'yrn' ) : chalk.red( 'npm' )
+
+  const { repoName, group } = repoLabel( dir, gitRoot )
+  return {
+    repoName,
+    group,
+    pkgMgr,
+    pkgVer      : fmtPkgVer( pkgVer ),
+    gitVer      : fmtGitVer( gitVer, pkgVer ),
+    dirty       : !syncOk,
+    scope       : fmtScope( pkg ),
+    isWorkspace,
+    checks      : CHECKS.map( ( { label, fn } ) => ( { label, ...fn( { dir, pkg, isWorkspace, gitRoot } ) } ) ),
+    needsPush,
+  }
+}
+
+// ---------- Table ----------
+
+function renderTable( rows ) {
+  const pkgW   = Math.max( 3, ...rows.map( r => visLen( r.pkgVer ) ) )
+  const gitW   = Math.max( 7, ...rows.map( r => visLen( r.gitVer ) ) )
+  const scopeW = Math.max( 4, ...rows.map( r => visLen( r.scope ) ) )
+
+  // Fixed width of all columns except name. Elements: mgr pkg git scope checks (no needsPush).
+  // join('  ') puts 2-space sep between N+5 elements = N+4 separators.
+  const checkLabelW = CHECKS.reduce( ( sum, c ) => sum + c.label.length, 0 )
+  const fixedW = 3 + pkgW + gitW + scopeW + checkLabelW + ( CHECKS.length + 4 ) * 2
+
+  // Name area: 2-space indent + repo name. Group label prints on its own line above each section.
+  const hasGroups = rows.some( r => r.group )
+  const indent    = hasGroups ? 2 : 0
+  const maxRepoW  = Math.min( 22, Math.max( 4, ...rows.map( r => r.repoName.length ) ) )
+  const nameW     = Math.min( indent + maxRepoW, 80 - fixedW )
+  const repoW     = nameW - indent
+
+  const nameHdr = pad( `${' '.repeat( indent )}name`, nameW )
+  const hdr = [
+    nameHdr,
+    center( 'mgr', 3 ),
+    center( 'pkg', pkgW ),
+    center( 'git', gitW ),
+    center( 'scop', scopeW ),
+    ...CHECKS.map( c => center( c.label, c.label.length ) ),
+  ].join( '  ' )
+
+  const separator = chalk.dim( '─'.repeat( visLen( hdr ) ) )
+
+  log( '' )
+  log( chalk.dim( hdr ) )
+  log( separator )
+
+  let currentGroup
+  for ( const row of rows ) {
+    if ( row.group !== currentGroup ) {
+      currentGroup = row.group
+      if ( hasGroups ) log( chalk.cyan( row.group ?? '' ) )
+    }
+    const nameStr  = ' '.repeat( indent ) + row.repoName.slice( 0, repoW )
+    const nameCell = row.dirty ? chalk.hex( '#FFA500' )( nameStr ) : nameStr
+    const line = [
+      pad( nameCell, nameW ),
+      pad( row.pkgMgr, 3 ),
+      pad( row.pkgVer, pkgW ),
+      pad( row.gitVer, gitW ),
+      pad( row.scope, scopeW ),
+      ...row.checks.map( c => center( c.value, c.label.length ) ),
+    ].join( '  ' ) + ( row.needsPush ? `  ${row.needsPush}` : '' )
+    log( line )
+  }
+
+  log( '' )
+}
+
+// ---------- CLI ----------
+
+program
+  .name( 'package-checker' )
+  .description( chalk.green( 'A panopticon for your git repos!' ) )
+  .argument( '<dirs...>', 'directories to check' )
+  .option( '--no-pull', 'skip git pull and tag fetch' )
+  .option( '--no-clear', 'do not clear the screen before output' )
+  .option( '--concurrency <n>', 'max parallel repos', '5' )
+  .option( '--limit <n>', 'max rows to display', '80' )
+  .option( '--debug', 'enable debug logging' )
+  .addHelpText( 'after', `
+${chalk.yellow( 'Columns:' )}
+  ${chalk.green( 'pkg' )}    version from package.json
+  ${chalk.green( 'git' )}    latest semver git tag (green=match, yellow=mismatch, red=untagged)
+  ${chalk.green( 'name' )}  orange if dirty: pull/fetch failed (regular repos) or local modifications present (workspace packages)
+  ${chalk.green( 'scope' )}  package scope: @org, PRVT, or PUBL
+  ${chalk.green( 'cir' )}    CircleCI config: ✘=missing, L=legacy, 1=orb v1, 2=orb v2
+  ${chalk.green( 'ESM' )}    "type": "module" in package.json
+  ${chalk.green( 'har' )}    .har directory present at repo root
+  ${chalk.green( 'lnt' )}    ESLint version from node_modules (✘=no lint script, ?=not installed, yellow=v8, green=v9+)
+
+${chalk.yellow( 'Monorepos:' )}
+  Workspace packages are discovered automatically — passing a monorepo root
+  expands its workspaces field so you never need to add packages/* globs.
+  Git tags are looked up as pkg-name/vX.Y.Z. Pull/fetch runs at the root.
+
+${chalk.yellow( 'Examples:' )}
+  ${chalk.green( 'package-checker ~/repos/my-service' )}
+  ${chalk.green( 'package-checker --no-pull ~/repos/*' )}
+  ${chalk.green( 'package-checker --concurrency 10 @plt/* @kud/* @srv/* @tpi/*' )}
+` )
+  .parse()
+
+const dirs = program.args
+const options = program.opts()
+if ( options.debug ) { enableDebug() }
+
+if ( options.clear ) { clear() }
+
+// Auto-expand workspace packages from any monorepo roots in the input.
+// Supports both array and yarn-style { packages: [...] } workspaces fields.
+async function expandWorkspaces( dir ) {
+  try {
+    const pkg = await parseJsonFile( path.join( dir, 'package.json' ) )
+    const patterns = Array.isArray( pkg?.workspaces ) ?
+      pkg.workspaces :
+      ( pkg?.workspaces?.packages ?? [] )
+    if ( !patterns.length ) return []
+    const matches = await Promise.all(
+      patterns.map( p => glob( p, { cwd : dir, absolute : true } ) )
+    )
+    return matches.flat().filter( d => !/test|demo/i.test( path.basename( d ) ) )
+  } catch {
+    return []
+  }
+}
+
+const resolvedDirs  = dirs.map( dir => path.resolve( dir ) )
+const wsExpansions  = ( await Promise.all( resolvedDirs.map( expandWorkspaces ) ) ).flat()
+const allDirs       = [ ...new Set( [ ...resolvedDirs, ...wsExpansions ] ) ]
+
+const total   = allDirs.length
+let completed = 0
+const spinner = ora( `Checking repos (0/${total})...` ).start()
+
+process.on( 'SIGINT', () => { spinner.stop(); process.exit( 1 ) } )
+
+const limit = pLimit( parseInt( options.concurrency, 10 ) )
+const results = await Promise.all(
+  allDirs.map( dir => limit( async () => {
+    const result = await checkRepo( dir, { pull : options.pull } )
+    spinner.text = `Checking repos (${++completed}/${total})...`
+    return result
+  } ) )
+)
+
+spinner.stop()
+
+const rows = results
+  .filter( Boolean )
+  .sort( ( a, b ) => {
+    const ga = a.group ?? ''
+    const gb = b.group ?? ''
+    if ( ga !== gb ) return ga.localeCompare( gb )
+    return a.repoName.localeCompare( b.repoName )
+  } )
+
+if ( rows.length === 0 ) {
+  log( chalk.yellow( '\nNo valid repositories found.\n' ) )
+  process.exit( 0 )
+}
+
+const maxRows   = parseInt( options.limit, 10 )
+const checked   = rows.length
+const displayed = rows.slice( 0, maxRows )
+
+renderTable( displayed )
+
+const summary = checked > displayed.length ?
+  `total repositories checked: ${checked} (${displayed.length} displayed)\n` :
+  `total repositories checked: ${checked}\n`
+log( summary )

package/src/service-man/config/CommandLine.mjs

@@ -94,12 +94,14 @@ const cliOptionList = [ // Use cliOptionList to tie into the Usage statements
     default : false,
     description : '{green display this help screen}',
   },
-  { name : 'version',
+  {
+    name : 'version',
     type : Boolean,
     default : false,
     description : '{green returns the build-tools repo version}',
   },
-  { name : 'verbose',
+  {
+    name : 'verbose',
     alias : 'v',
     type : Boolean,
     default : false,
@@ -114,7 +116,8 @@ const sections = [
   {green This utility attempts to ease the pain of managing IAM roles and the creation of service accounts for new clusters and services.}
 `,
   },
-  { header : 'Options',
+  {
+    header : 'Options',
     optionList : cliOptionList,
   },
 ]

package/src/service-man/config/Config.mjs

@@ -57,7 +57,7 @@ export default class Config {
   Remove => ` + chalk.yellow.bold( dumpDir ) )
         process.exit( 1 )
       }
-    } catch ( err ) {
+    } catch ( err ) { // eslint-disable-line no-unused-vars
       // this file does not exist is a good thing
     }
 

package/src/service-man/gcloud-k8s/RolesManager.mjs

@@ -24,7 +24,7 @@ export default class RolesManager {
         /* eslint-disable-next-line no-await-in-loop */
         await shellCmd( `gcloud iam roles ${iamVerb} ${roleName} --project ${k8sProject}` )
         iamVerb = 'update' // no err then the role exists - do an update
-      } catch ( err ) {
+      } catch ( err ) { // eslint-disable-line no-unused-vars
         iamVerb = 'create' // failed call so role does not exist - create it
       }
 

package/src/service-man/gcloud-k8s/SecretsManager.mjs

@@ -42,7 +42,7 @@ export default class SecretsManager {
     try {
       await shellCmd( `gcloud secrets describe ${key} --project ${project}` )
       exists = true
-    } catch ( err ) {
+    } catch ( err ) { // eslint-disable-line no-unused-vars
       exists = false
     }
 
@@ -72,7 +72,7 @@ export default class SecretsManager {
       if ( labelStr ) createCmd.push( `--labels=${labelStr}` )
       if ( annotationStr ) createCmd.push( `--set-annotations=${annotationStr}` )
       await shellCmd( createCmd, { input : value } )
-    } catch ( err ) {
+    } catch ( err ) { // eslint-disable-line no-unused-vars
       log( chalk.red( `\nSM secret write failed for ${key}\n` ) )
     }
   }
@@ -136,7 +136,7 @@ ${dataLines}
       log( `  Applying ExternalSecret => ${chalk.green( name )} in ${chalk.yellow( namespace )}` )
       try {
         await shellCmd( [ 'kubectl', 'apply', '-f', '-' ], { input : yaml } ) // eslint-disable-line no-await-in-loop
-      } catch ( err ) {
+      } catch ( err ) { // eslint-disable-line no-unused-vars
         log( chalk.red( `\nExternalSecret apply failed for ${name}\n` ) )
       }
     }

package/src/service-man/gcloud-k8s/ServiceAccountManager.mjs

@@ -74,7 +74,7 @@ export default class ServiceAccountManager {
       try {
         await shellCmd( `${command} ${options}` ) // eslint-disable-line no-await-in-loop
         return true
-      } catch ( err ) {
+      } catch ( err ) { // eslint-disable-line no-unused-vars
         log( '   IAM propagating => ', chalk.yellow( role ) )
       }
       await delayWithBackoff( retryCount ) // eslint-disable-line no-await-in-loop
@@ -108,7 +108,7 @@ export default class ServiceAccountManager {
       try {
         await shellCmd( `${command} ${options}` ) // eslint-disable-line no-await-in-loop
         return true
-      } catch ( err ) {
+      } catch ( err ) { // eslint-disable-line no-unused-vars
         await delayWithBackoff( retryCount ) // eslint-disable-line no-await-in-loop
       }
     }
@@ -136,7 +136,7 @@ export default class ServiceAccountManager {
         if ( shellOut.match( `email: ${serviceName}` ) ) {
           return true
         }
-      } catch ( err ) {
+      } catch ( err ) { // eslint-disable-line no-unused-vars
         log( '            SA propagating => ', chalk.yellow( serviceName ) )
         await delayWithBackoff( retryCount ) // eslint-disable-line no-await-in-loop
       }
@@ -220,7 +220,7 @@ export default class ServiceAccountManager {
           log( '\nSkip existing SvcAct =>', chalk.yellow( saName ) )
           continue
         }
-      } catch ( err ) {
+      } catch ( err ) { // eslint-disable-line no-unused-vars
         log( '\nCreating new SvcAcct =>', chalk.green( saName ) )
       }
 

package/src/unleash.mjs

@@ -39,7 +39,7 @@ const npmRunner = async ( script ) => {
     const cmd = `npm run ${script}`
     const results = await shellCmd( cmd, { stdio : 'inherit' } )
     return results
-  } catch ( err ) {
+  } catch ( err ) { // eslint-disable-line no-unused-vars
     process.exit( 1 )
   }
   return undefined

package/src/pkgck.sh

@@ -1,158 +0,0 @@
-#!/bin/bash
-
-C_off='\e[0m'
-C_yellow='\e[93m'
-C_red='\e[101m'
-C_green='\e[92m'
-
-good() {
-  printf "\e[32m✔${C_off}"
-}
-
-meh() {
-  printf "\e[36m✩${C_off}"
-}
-
-bad() {
-  printf "\e[31m✘${C_off}"
-}
-
-semver() {
-  local version=$1
-  local isSemver=`echo $version | egrep -e "^v\d+\.\d+\.\d+$"`
-  if [ -z "$version" ];
-  then
-    printf "UNTAGGD"
-  elif [ $isSemver ];
-  then
-    printf "$version"
-  else
-    printf "!SEMVER"
-  fi
-}
-
-check_babel () {
-  local C_stat=$(bad)
-  [ -f .babelrc ] && grep --silent @leverege/babel-preset-leverege-node .babelrc
-  [ $? -eq 0 ] && C_stat=$(good)
-  [ ! -f .babelrc ] && C_stat=$(meh)
-  printf $C_stat
-}
-
-check_har () {
-  local C_stat=$(bad)
-  local prep="`node -p \"require('./package.json').scripts.prepare\"`"
-  local isHar=`echo $prep | egrep -e "hook-and-release"`
-  [ ! -z "$isHar" ] && C_stat=$(good)
-  printf $C_stat
-}
-
-check_circle () {
-  local C_stat=$(bad)
-  [ -f ".circleci/config.yml" ] && C_stat=$(good)
-  printf $C_stat
-}
-
-check_eslint () {
-  local C_stat=$(bad)
-  [ -f .eslintrc ] && grep --silent @leverege/eslint-config-leverege .eslintrc
-  [ $? -eq 0 ] && C_stat=$(good)
-  printf $C_stat
-}
-
-check_license () {
-  local C_stat=$(meh)
-  local lic="`node -p \"require('./package.json').scripts.licenseCheck == undefined\"`"
-  [ $lic == true ] && C_stat=$(good)
-  printf $C_stat
-}
-
-# Invoke as: version_ck $GITTAG $NPMVER
-#
-check_git_version() {
-  local tag=$1
-  local pkg=$2
-  local clr=$C_green
-
-  if [ "$tag" == 'UNTAGGD' ];
-  then
-    clr=$C_red
-  elif [ "$tag" != "$pkg" ];
-  then
-    clr=$C_yellow
-  fi
-
-  printf "$clr$tag$C_off"
-}
-
-#check_nodemon() {
-#  nodemon="`getjson --file ./package.json --key nodemon`"
-#}
-
-check_scope() {
-  private="`node -p \"require('./package.json').private == true\"`"
-  scoped="`getjson --file ./package.json --key name --regex '^@\w{3}'`"
-  result="${C_red}PUBL${C_off}"
-  if [[ "$scoped" == "" ]] && [[ "$private" == "true" ]];
-  then
-    result="${C_yellow}PRVT"
-  elif [[ "$scoped" != "" ]];
-  then
-    result="${C_green}${scoped}"
-  elif [[ "$private" == "true" ]];
-  then
-    result="${C_green}prv"
-  fi
-  printf "${result}${C_off}"
-}
-
-check_ESM() {
-  local C_stat=$(bad)
-  jstype="`getjson --file package.json --key type`"
-  [[ "$jstype" == "module" ]] && C_stat=$(good)
-  printf $C_stat
-}
-
-repos=0
-check_repo() {
-  local dir=$1
-  [ ! -d $dir/.git ] || [ ! -f $dir/package.json ] && return
-  cd $dir &> /dev/null
-  local gperrs=0
-  git pull -q &> /dev/null;        [ $? -ne 0 ] && let "gperrs++"
-  git pull -q --tags &> /dev/null; [ $? -ne 0 ] && let "gperrs++"
-
-  # It is necessary to use the output from printf to set localmods in order
-  # to get the ANSI escape codes expanded.
-  local localmods=$(good)
-  [ $gperrs -ne 0 ] && localmods=$(bad)
-  pkgver=$(semver "v`node -p \"require('./package.json').version\"`")
-  gitver=$(semver `git describe --abbrev=0 2>/dev/null`)
-  [ $? -ne 0 ] && gitver='UNTAGGD'
-  local needspush=
-  if [ "$pkgver" == "$gitver" ];
-  then
-    git ls-remote --tags origin | grep $gitver &> /dev/null
-    [ $? -ne 0 ] && needspush='!tags'
-  fi
-  local babel7=$(check_babel)
-  local hookar=$(check_har)
-  local circle=$(check_circle)
-  local eslint=$(check_eslint)
-  local esmlib=$(check_ESM)
-  local license=$(check_license)
-  local scoped=$(check_scope)
-  [ $(( $repos % 15)) -eq 0 ] && printf "\n%35s pkg      git  cln scop cir lic ESM har\n"
-  printf "%32s: %-8s %-16s %s  %8s  %s   %s   %s   %s  %s\n" ${dir:0:32} $pkgver $(check_git_version $gitver $pkgver) $localmods $scoped $circle $license $esmlib $hookar "$needspush"
-  let "repos++"
-  cd - &> /dev/null
-}
-
-clear
-
-pkgs="$@"
-for dir in $@; do
-  check_repo $dir
-done
-
-printf "\ntotal repoitories checked: $repos\n\n"