enablement-build-monorepo-version 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Chris Doty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# enablement-build-monorepo-version
+
+This detects changes in the children packages of a monorepo.
+
+

package/folder-hash.mjs

@@ -0,0 +1,425 @@
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+import minimatch from 'minimatch';
+
+const defaultOptions = {
+  algo: 'sha1', // see crypto.getHashes() for options
+  encoding: 'base64', // 'base64', 'base64url', 'hex' or 'binary'
+  files: {
+    exclude: [],
+    include: [],
+    matchBasename: true,
+    matchPath: false,
+    ignoreBasename: false,
+    ignoreRootName: false,
+  },
+  folders: {
+    exclude: [],
+    include: [],
+    matchBasename: true,
+    matchPath: false,
+    ignoreBasename: false,
+    ignoreRootName: false,
+  },
+  symbolicLinks: {
+    include: true,
+    ignoreBasename: false,
+    ignoreTargetPath: true,
+    ignoreTargetContent: false,
+    ignoreTargetContentAfterError: false,
+  },
+};
+
+const debug = function(txt) {
+  return params => {
+    console.log(txt, params);
+    return params;
+  }
+}
+
+// Use the environment variable DEBUG to log output, e.g. `set DEBUG=fhash:*`
+const log = {
+  match: function() {},
+  params: function(params) {return params},
+  err: debug('fhash:err'),
+  symlink: debug('fhash:symlink'),
+  queue: function() {}
+};
+
+function prep(fs) {
+  let queue = [];
+  let queueTimer = undefined;
+
+  function hashElement(name, dir, options, callback) {
+    callback = arguments[arguments.length - 1];
+
+    return parseParameters(arguments)
+      .then(({ basename, dir, options }) => {
+        // this is only used for the root level
+        options.skipMatching = true;
+        return fs.promises
+          .lstat(path.join(dir, basename))
+          .then(stats => {
+            stats.name = basename;
+            return stats;
+          })
+          .then(stats => hashElementPromise(stats, dir, options, true));
+      })
+      .then(result => {
+        if (isFunction(callback)) {
+          return callback(undefined, result);
+        } else {
+          return result;
+        }
+      })
+      .catch(reason => {
+        log.err('Fatal error:', reason);
+        if (isFunction(callback)) {
+          return callback(reason);
+        } else {
+          throw reason;
+        }
+      });
+  }
+
+  /**
+   * @param {fs.Stats} stats folder element, can also be of type fs.Dirent
+   * @param {string} dirname
+   * @param {Options} options
+   * @param {boolean} isRootElement
+   */
+  function hashElementPromise(stats, dirname, options, isRootElement = false) {
+    const name = stats.name;
+    let promise = undefined;
+    if (stats.isDirectory()) {
+      promise = hashFolderPromise(name, dirname, options, isRootElement);
+    } else if (stats.isFile()) {
+      promise = hashFilePromise(name, dirname, options, isRootElement);
+    } else if (stats.isSymbolicLink()) {
+      promise = hashSymLinkPromise(name, dirname, options, isRootElement);
+    } else {
+      log.err('hashElementPromise cannot handle ', stats);
+      return Promise.resolve({ name, hash: 'Error: unknown element type' });
+    }
+
+    return promise.catch(err => {
+      if (err.code && (err.code === 'EMFILE' || err.code === 'ENFILE')) {
+        log.queue(`queued ${dirname}/${name} because of ${err.code}`);
+
+        const promise = new Promise((resolve, reject) => {
+          queue.push(() => {
+            log.queue(`Will processs queued ${dirname}/${name}`);
+            return hashElementPromise(stats, dirname, options, isRootElement)
+              .then(ok => resolve(ok))
+              .catch(err => reject(err));
+          });
+        });
+
+        if (queueTimer === undefined) {
+          queueTimer = setTimeout(processQueue, 0);
+        }
+        return promise;
+      }
+
+      throw err;
+    });
+  }
+
+  function processQueue() {
+    queueTimer = undefined;
+    const runnables = queue;
+    queue = [];
+    runnables.forEach(run => run());
+  }
+
+  async function hashFolderPromise(name, dir, options, isRootElement = false) {
+    const folderPath = path.join(dir, name);
+    let ignoreBasenameOnce = options.ignoreBasenameOnce;
+    delete options.ignoreBasenameOnce;
+
+    if (options.skipMatching) {
+      // this is currently only used for the root folder
+      log.match(`skipped '${folderPath}'`);
+      delete options.skipMatching;
+    } else if (ignore(name, folderPath, options.folders)) {
+      return undefined;
+    }
+
+    const files = await fs.promises.readdir(folderPath, { withFileTypes: true });
+    const children = await Promise.all(
+      files
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(child => hashElementPromise(child, folderPath, options)),
+    );
+
+    if (ignoreBasenameOnce) options.ignoreBasenameOnce = true;
+    const hash = new HashedFolder(name, children.filter(notUndefined), options, isRootElement);
+    return hash;
+  }
+
+  function hashFilePromise(name, dir, options, isRootElement = false) {
+    const filePath = path.join(dir, name);
+
+    if (options.skipMatching) {
+      // this is currently only used for the root folder
+      log.match(`skipped '${filePath}'`);
+      delete options.skipMatching;
+    } else if (ignore(name, filePath, options.files)) {
+      return Promise.resolve(undefined);
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        const hash = crypto.createHash(options.algo);
+        if (
+          options.files.ignoreBasename ||
+          options.ignoreBasenameOnce ||
+          (isRootElement && options.files.ignoreRootName)
+        ) {
+          delete options.ignoreBasenameOnce;
+          log.match(`omitted name of ${filePath} from hash`);
+        } else {
+          hash.update(name);
+        }
+
+        const f = fs.createReadStream(filePath);
+        f.on('error', err => {
+          reject(err);
+        });
+        f.pipe(hash, { end: false });
+
+        f.on('end', () => {
+          const hashedFile = new HashedFile(name, hash, options.encoding);
+          return resolve(hashedFile);
+        });
+      } catch (ex) {
+        return reject(ex);
+      }
+    });
+  }
+
+  async function hashSymLinkPromise(name, dir, options, isRootElement = false) {
+    const target = await fs.promises.readlink(path.join(dir, name));
+    log.symlink(`handling symbolic link ${name} -> ${target}`);
+    if (options.symbolicLinks.include) {
+      if (options.symbolicLinks.ignoreTargetContent) {
+        return symLinkIgnoreTargetContent(name, target, options, isRootElement);
+      } else {
+        return symLinkResolve(name, dir, target, options, isRootElement);
+      }
+    } else {
+      log.symlink('skipping symbolic link');
+      return Promise.resolve(undefined);
+    }
+  }
+
+  function symLinkIgnoreTargetContent(name, target, options, isRootElement) {
+    delete options.skipMatching; // only used for the root level
+    log.symlink('ignoring symbolic link target content');
+    const hash = crypto.createHash(options.algo);
+    if (!options.symbolicLinks.ignoreBasename && !(isRootElement && options.files.ignoreRootName)) {
+      log.symlink('hash basename');
+      hash.update(name);
+    }
+    if (!options.symbolicLinks.ignoreTargetPath) {
+      log.symlink('hash targetpath');
+      hash.update(target);
+    }
+    return Promise.resolve(new HashedFile(name, hash, options.encoding));
+  }
+
+  async function symLinkResolve(name, dir, target, options, isRootElement) {
+    delete options.skipMatching; // only used for the root level
+    if (options.symbolicLinks.ignoreBasename) {
+      options.ignoreBasenameOnce = true;
+    }
+
+    try {
+      const stats = await fs.promises.stat(path.join(dir, name));
+      stats.name = name;
+      const temp = await hashElementPromise(stats, dir, options, isRootElement);
+
+      if (!options.symbolicLinks.ignoreTargetPath) {
+        const hash = crypto.createHash(options.algo);
+        hash.update(temp.hash);
+        log.symlink('hash targetpath');
+        hash.update(target);
+        temp.hash = hash.digest(options.encoding);
+      }
+      return temp;
+    } catch (err) {
+      if (options.symbolicLinks.ignoreTargetContentAfterError) {
+        log.symlink(`Ignoring error "${err.code}" when hashing symbolic link ${name}`, err);
+        const hash = crypto.createHash(options.algo);
+        if (
+          !options.symbolicLinks.ignoreBasename &&
+          !(isRootElement && options.files.ignoreRootName)
+        ) {
+          hash.update(name);
+        }
+        if (!options.symbolicLinks.ignoreTargetPath) {
+          hash.update(target);
+        }
+        return new HashedFile(name, hash, options.encoding);
+      } else {
+        log.symlink(`Error "${err.code}": When hashing symbolic link ${name}`, err);
+        throw err;
+      }
+    }
+  }
+
+  function ignore(name, path, rules) {
+    if (rules.exclude) {
+      if (rules.matchBasename && rules.exclude(name)) {
+        log.match(`exclude basename '${name}'`);
+        return true;
+      } else if (rules.matchPath && rules.exclude(path)) {
+        log.match(`exclude path '${path}'`);
+        return true;
+      }
+    }
+    if (rules.include) {
+      if (rules.matchBasename && rules.include(name)) {
+        log.match(`include basename '${name}'`);
+        return false;
+      } else if (rules.matchPath && rules.include(path)) {
+        log.match(`include path '${path}'`);
+        return false;
+      } else {
+        log.match(`include rule failed for path '${path}'`);
+        return true;
+      }
+    }
+
+    log.match(`Will not ignore unmatched '${path}'`);
+    return false;
+  }
+
+  return hashElement;
+}
+
+function parseParameters(args) {
+  let basename = args[0],
+    dir = args[1],
+    options_ = args[2];
+
+  if (!isString(basename)) {
+    return Promise.reject(new TypeError('First argument must be a string'));
+  }
+
+  if (!isString(dir)) {
+    dir = path.dirname(basename);
+    basename = path.basename(basename);
+    options_ = args[1];
+  }
+
+  // parse options (fallback default options)
+  if (!isObject(options_)) options_ = {};
+  const options = {
+    algo: options_.algo || defaultOptions.algo,
+    encoding: options_.encoding || defaultOptions.encoding,
+    files: Object.assign({}, defaultOptions.files, options_.files),
+    folders: Object.assign({}, defaultOptions.folders, options_.folders),
+    match: Object.assign({}, defaultOptions.match, options_.match),
+    symbolicLinks: Object.assign({}, defaultOptions.symbolicLinks, options_.symbolicLinks),
+  };
+
+  // transform match globs to Regex
+  options.files.exclude = reduceGlobPatterns(options.files.exclude);
+  options.files.include = reduceGlobPatterns(options.files.include);
+  options.folders.exclude = reduceGlobPatterns(options.folders.exclude);
+  options.folders.include = reduceGlobPatterns(options.folders.include);
+
+  return Promise.resolve(log.params({ basename, dir, options }));
+}
+
+const HashedFolder = function HashedFolder(name, children, options, isRootElement = false) {
+  this.name = name;
+  this.children = children;
+
+  const hash = crypto.createHash(options.algo);
+  if (
+    options.folders.ignoreBasename ||
+    options.ignoreBasenameOnce ||
+    (isRootElement && options.folders.ignoreRootName)
+  ) {
+    delete options.ignoreBasenameOnce;
+    log.match(`omitted name of folder ${name} from hash`);
+  } else {
+    hash.update(name);
+  }
+  children.forEach(child => {
+    if (child.hash) {
+      hash.update(child.hash);
+    }
+  });
+
+  this.hash = hash.digest(options.encoding);
+};
+
+HashedFolder.prototype.toString = function (padding = '') {
+  const first = `${padding}{ name: '${this.name}', hash: '${this.hash}',\n`;
+  padding += '  ';
+
+  return `${first}${padding}children: ${this.childrenToString(padding)}}`;
+};
+
+HashedFolder.prototype.childrenToString = function (padding = '') {
+  if (this.children.length === 0) {
+    return '[]';
+  } else {
+    const nextPadding = padding + '  ';
+    const children = this.children.map(child => child.toString(nextPadding)).join('\n');
+    return `[\n${children}\n${padding}]`;
+  }
+};
+
+const HashedFile = function HashedFile(name, hash, encoding) {
+  this.name = name;
+  this.hash = hash.digest(encoding);
+};
+
+HashedFile.prototype.toString = function (padding = '') {
+  return padding + "{ name: '" + this.name + "', hash: '" + this.hash + "' }";
+};
+
+function isFunction(any) {
+  return typeof any === 'function';
+}
+
+function isString(str) {
+  return typeof str === 'string' || str instanceof String;
+}
+
+function isObject(obj) {
+  return obj !== null && typeof obj === 'object';
+}
+
+function notUndefined(obj) {
+  return typeof obj !== 'undefined';
+}
+
+function reduceGlobPatterns(globs) {
+  if (isFunction(globs)) {
+    return globs;
+  } else if (!globs || !Array.isArray(globs) || globs.length === 0) {
+    return undefined;
+  } else {
+    // combine globs into one single RegEx
+    const regex = new RegExp(
+      globs
+        .reduce((acc, exclude) => {
+          return acc + '|' + minimatch.makeRe(exclude).source;
+        }, '')
+        .substr(1),
+    );
+    return param => regex.test(param);
+  }
+}
+
+const hashElement = prep(fs);
+export {
+  defaultOptions as defaults,
+  hashElement
+};

package/index.mjs

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+import path from 'path';
+import { readFile,readFileSync, writeFile, writeFileSync, existsSync, lstatSync } from "fs";
+import { exec } from "child_process";
+
+import { hashElement } from "./folder-hash.mjs";
+import { Version } from "./version.mjs";
+
+
+function dependencyMap(outputFile) {
+  let depends = readFileSync(outputFile,"utf8");
+  depends = JSON.parse(depends).graph.dependencies;
+  let keys = Object.keys(depends);
+  let inverted = {};
+  for(let i=0;i<keys.length;i++) {
+    let name = keys[i];
+    let p = depends[name];
+    for(let j=0;j<p.length;j++) {
+      var d = p[j];
+      inverted[d.target] = inverted[d.target]||[];
+      inverted[d.target].push(name);
+    }
+  }
+  return inverted;
+}
+
+
+function buildResult(packageFolder, name,last_version,status,options) {
+  if(options.debug) console.log(packageFolder, name,`- ${status}`);
+  if(options.version) {
+    let version_file = path.join(options.prefixPath, packageFolder,name,"package.json");
+    return Version(name,last_version,version_file, options,{"name":name,changed:(status!="UNCHANGED"),status,packageFolder});
+  } else {
+    return new Promise((resolve, reject) => {
+      resolve({"name":name,changed:(status!="UNCHANGED"),status,packageFolder});
+    });
+  }
+}
+
+function getCurrentVersion(pathPrefix,packageFolder, name) {
+  const projectFile = path.join(pathPrefix, packageFolder,name,"package.json");
+
+  if(!existsSync(projectFile)) return {"version":"0.0.0"};
+  let data = readFileSync(projectFile, "utf8")
+  let pkg = JSON.parse(data);
+  return {version:pkg.version,fullName:pkg.name,packageFolder};
+}
+
+async function updateVersion(packageFolder,name,version) {
+  var value = new Promise((resolve, reject) => {
+    const projectFile = path.join(options.prefixPath, packageFolder,name,"package.json");
+    if(!existsSync(projectFile)) return resolve("NOT FOUND");
+
+    readFile(projectFile, "utf8", (error, data) => {
+      if (error) {
+        console.log(error);
+        reject(error);
+        return;
+      }
+      let versionFile = JSON.parse(data);
+      if(versionFile["version"]!==version) {
+        versionFile["version"] = version;
+        writeFile(projectFile, JSON.stringify(versionFile, null, 2), "utf8",
+            (error) => {
+              if (error) {
+                console.log(error);
+                reject(error);
+                return;
+              }
+              resolve("OK");
+            });
+      } else resolve("NOT NEEDED");
+    });
+
+  });
+
+  return value;
+}
+
+
+async function compare(packageFolder, previous,current,dependencies,options) {
+  let packages = Object.keys(current);
+  let plist = [];
+  let nameMap = {};
+
+  packages.forEach((name) => {
+    let fullName = current[name].fullName;
+    nameMap[fullName] = name;
+  });
+
+  packages.forEach((name) => {
+    let fullName = current[name].fullName;
+    if(current[name].packageFolder!==packageFolder) return;
+    if(previous[name]===undefined) {
+      plist.push(buildResult(packageFolder,name,current[name].version,"NEW",options));
+    } else {
+      if(current[name].hash!==previous[name].hash) {
+        plist.push(buildResult(packageFolder,name,current[name].version,"CHANGED",options));
+        if(dependencies[fullName] && dependencies[fullName].length>0) {
+          let d = dependencies[fullName];
+          for(let i=0;i<d.length;i++) {
+            let depName = nameMap[d[i]];
+            plist.push(buildResult(packageFolder,depName,current[depName].version,"CHANGED",options));
+          }
+        }
+      } else {
+        plist.push(buildResult(packageFolder,name,current[name].version,"UNCHANGED",options));
+      }
+    }
+  });
+  return Promise.allSettled(plist);
+}
+
+async function main(options) {
+  return new Promise((mainResolve, mainreject) => {
+    const hashOptions = { encoding: 'hex', folders: { exclude: options.hashExcludeFolders }, files: { exclude: options.hashExcludeFiles } }
+    const current = {};
+    const changeList = [];
+    const scanlist = [];
+
+    options.children.split(',').forEach((packageFolder)=>{
+      scanlist.push(new Promise((resolve, reject) => {
+        hashElement(path.join(options.prefixPath,packageFolder), hashOptions).then(async hash => {
+          // calculate latest folder hashes
+          const children = hash.children;
+          for(let i=0;i<children.length;i++)
+          {
+            let name = children[i].name;
+            if(name.substring(0,1)==="_" || name==="version" ) continue;
+            if(lstatSync(path.join( options.prefixPath, packageFolder,name)).isFile()) continue;
+            if(!existsSync(path.join( options.prefixPath, packageFolder,name))) continue;
+
+            delete children[i].children;
+            let v = getCurrentVersion(options.prefixPath,packageFolder,name);
+            current[name]={hash:children[i].hash,...v};
+          }
+
+          const changeConfig = path.join(options.prefixPath,options.hashFile);
+          let previous = {};
+
+          // make sure hash config file exits
+          if(!existsSync(changeConfig)) {
+            writeFileSync(changeConfig, "{}", "utf8");
+          }
+
+          // load previous hashes
+          readFile(changeConfig, "utf8", async (error, data) => {
+            if (error) {
+              console.log(error);
+              reject(error);
+              return;
+            }
+            previous=JSON.parse(data);
+
+            if(options.changed || options.version) {
+
+              let dependencies={};
+              if(options.dependencies) {
+                if(existsSync(options.dependencies)) {
+                  dependencies = dependencyMap(options.dependencies);
+                  if(options.debug) console.log('Loaded dependencies\n',JSON.stringify(dependencies));
+                } else {
+                  console.log('\x1b[33m%s\x1b[0m', `Could not load dependency file ${options.dependencies}`);
+                }
+              }
+
+              let results = await compare(packageFolder, previous,current,dependencies,options);
+              if(options.debug) console.log(JSON.stringify(results));
+
+              for(let i=0;i<results.length;i++) {
+                if(results[i].value.changed)
+                  changeList.push(results[i].value.name)
+              }
+
+              let plist=[];
+              for(let i=0;i<results.length;i++) {
+                if(results[i].value.packageFolder!==packageFolder) continue;
+                if(options.version) {
+                  if(options.debug) console.log(results[i]);
+                  let safeName = results[i].value.name;
+                  safeName=safeName.replace(/-/g,'_');
+                  if(results[i].value.changed) {
+                    console.log(`##vso[task.setvariable variable=${safeName};isoutput=true;]${results[i].value.version}`);
+                    if(options.saveVersion) {
+                      plist.push(updateVersion(packageFolder,results[i].value.name,results[i].value.version));
+                    }
+                  } else {
+                    console.log(`##vso[task.setvariable variable=${safeName};isoutput=true;]${results[i].value.previous}`);
+                  }
+                }
+                if(options.tag) {
+                  plist.push(new Promise((resolve,reject)=>{
+                    let rev=results[i].value.name+'@'+results[i].value.version;
+                    exec(`git describe --tags ${rev}`, (err, tag, stderr) => {
+                      if (err) {
+                          exec(`git tag ${rev} -m "${rev}"`, (err, tag, stderr) => {
+                            if (err) {
+                                reject(err);
+                                return;
+                            }
+                            resolve(rev);
+                          });
+                          return;
+                      }
+                    });
+                  }));
+                }
+              }
+              if(plist.length>0 && options.debug) {
+                console.log(await Promise.allSettled(plist));
+              }
+            }
+
+            // write current hashes
+            if(options.hash) {
+              let names = Object.keys(current);
+              for(let i=0;i<names.length;i++) {
+                if(current[names[i]].packageFolder!==packageFolder) continue;
+                let v = getCurrentVersion(options.prefixPath,packageFolder,names[i]);
+                current[names[i]].version = v.version;
+                current[names[i]].fullName = v.fullName;
+              }
+
+              writeFileSync(changeConfig, JSON.stringify(current, null, 2), "utf8");
+              console.log('folder hashes written successfully');
+            }
+
+            resolve("OK");
+          });
+        })
+        .catch(error => {
+          return console.error('hashing failed:', error);
+        });
+      }));
+    });
+
+    Promise.all(scanlist).then(()=>{
+      if(options.changed) {
+        console.log(`CHANGED - ${JSON.stringify(changeList)}`);
+        console.log(`##vso[task.setvariable variable=changed;isoutput=true]${JSON.stringify(changeList)}`);
+      }
+
+      mainResolve("DONE");
+    },mainreject);
+  });
+}
+
+let options = {
+    saveVersion:false,
+    changed:false,
+    version:false,
+    hash:false,
+    tag:false,
+    commit:false,
+    // push:false,
+    children:"packages",
+    prefixPath:'./',
+    debug:false,
+    hashFile:".cicd/hash.json",
+    hashExcludeFolders:['node_modules', 'coverage', 'dist'],
+    hashExcludeFiles:['.npmrc','CHANGELOG.md','README.md'],
+    dependencies:"dependencies.json"
+};
+
+if (process.argv.length === 2) {
+  console.error('Expected at least one argument!');
+  process.exit(1);
+} else {
+  let argv = process.argv;
+  for(let i=2;i<argv.length;i++) {
+    if(argv[i]==="--save") options.saveVersion=true;
+    else if(argv[i]==="--debug") options.debug=true;
+    else if(argv[i]==="--changed") options.changed=true;
+    else if(argv[i]==="--version") options.version=true;
+    else if(argv[i]==="--hash") options.hash=true;
+    else if(argv[i]==="--tag") options.tag=true;
+    else if(argv[i]==="--hashExcludeFolders" || argv[i]==="--hashExcludeFiles") {
+      let name = argv[i].substring(2);
+      options[name] = argv[i+1].split(',');
+      i++;
+    } else
+    if(argv[i].substring(0,2)==="--") {
+      let name = argv[i].substring(2);
+      if(options[name]!==undefined) {
+          options[name] = argv[i+1];
+          i++;
+      } else {
+          console.error(`Expected a known option, got ${argv[i]}`);
+          process.exit(1);
+      }
+    }
+  }
+}
+
+(async () => {
+  try {
+      const text = await main(options);
+      console.log(text);
+  } catch (e) {
+      console.log(e);
+      process.exit(1);
+  }
+})();

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "enablement-build-monorepo-version",
+  "version": "1.0.1",
+  "description": "This detects changes in the children packages of a monorepo.",
+  "type": "module",
+  "module": "./index.mjs",
+  "bin": "./index.mjs",
+  "license": "MIT",
+  "author": "Chris Doty",
+  "scripts": {
+    "start": "node index.mjs"
+  },
+  "dependencies": {
+    "minimatch": "~5.1.2"
+  }
+}

package/version.mjs

@@ -0,0 +1,89 @@
+import * as url from 'url';
+import fs from "fs";
+import { exec } from "child_process";
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+const processMessage = function(message,tag,imageName, options, args) {
+    let previous = tag;
+    let parts = tag.split('@');
+    if(parts.length>1) tag=parts[1];
+    let suffix = tag.trim().split('-');
+    if(suffix.length>0) {
+      tag=suffix[0];
+      suffix=suffix[1];
+    } else suffix=false;
+
+    parts = tag.trim().split('.');
+    parts.length = 3;
+    let build = false;
+
+    console.log("PROCESS -",imageName,tag,message)
+
+    if (message.indexOf("fix:") >= 0 || message==='') {
+        parts[2] = parseInt(parts[2]);
+        parts[2]++;
+        build = true;
+    }
+    if (message.indexOf("feat:") >= 0) {
+        parts[1] = parseInt(parts[1]);
+        parts[1]++;
+        parts[2] = 0;
+        build = true;
+    }
+    if (message.indexOf("BREAKING") >= 0) {
+        parts[0] = parseInt(parts[0]);
+        parts[0]++;
+        parts[1] = '0';
+        parts[2] = '0';
+        build = true;
+    }
+
+    tag = parts.join('.');
+    if(suffix) tag=tag+'-'+suffix;
+
+    if(options.debug) console.log('\x1b[32m%s\x1b[0m', `Next version: ${imageName}@${tag}`);
+    return {"name":imageName, "tag":tag,"version":tag, build, previous, ...args};
+};
+
+async function Version(imageName, last_version, version_file, options, args)
+{
+
+    const readConfig = function(resolve, reject) {
+        try {
+            if(options.debug) console.log('\x1b[32m%s\x1b[0m', `reading config: ${version_file}`);
+
+            let data = fs.readFileSync(version_file, 'utf8');
+            let tag = JSON.parse(data).version;
+            tag = tag.trim();
+            if(options.debug) console.log('\x1b[32m%s\x1b[0m', `Found version: ${imageName}@${tag}`);
+            resolve(processMessage("fix: no version tag found", tag, imageName, options, args));
+        } catch {
+            if(options.debug) console.log('\x1b[33m%s\x1b[0m', 'Could not find last or next version: ');
+            resolve({"name":imageName,"tag":`${imageName}@0.0.0`,"previous":"0.0.0","version":"0.0.1", ...args});
+        }
+    };
+
+    // if(args.changed)
+    //     return new Promise((resolve, reject) => {
+    //         let cmd= `git log ${imageName}/${last_version}..HEAD --oneline -- packages/spinner --no-merges`;
+    //         exec(cmd, (err, message, stderr) => {
+    //             if (err) {
+    //                 console.log('\x1b[33m%s\x1b[0m', 'Could not find any revisions because: ');
+    //                 console.log('\x1b[31m%s\x1b[0m', stderr);
+    //                 console.log('\x1b[31m%s\x1b[0m', cmd);
+
+    //                 readConfig(resolve, reject);
+
+    //                 return;
+    //             }
+    //             resolve(processMessage(message, last_version, imageName, options, args));
+    //         });
+    //     });
+
+    return new Promise((resolve, reject) => {
+        readConfig(resolve, reject)
+    });
+}
+
+export { Version };