enablement-build-monorepo-version 2.0.8 → 6.0.0

package/README.md

@@ -13,7 +13,7 @@ npx enablement-build-monorepo-version@latest [flags]
 ## How it works
 
 1. **Hash** — Each subfolder under the configured `children` directories is hashed (source files only; `node_modules`, `dist`, etc. are excluded).
-2. **Compare** — Hashes are diffed against saved state from `{configDir}/manifest.json` when present (`cicd[packageName].hash`), falling back to `{configDir}/hash.json` for legacy repos.
+2. **Compare** — Hashes are diffed against state in `--hashFile`, which defaults to `{configDir}/hash.json`.
 3. **Propagate** — Any package whose hash changed is marked `CHANGED`. All transitive dependents (read from `{configDir}/manifest.json` `dependencies` when available, or from `--dependencies` when explicitly provided) are also marked `CHANGED` via a breadth-first traversal.
 4. **Version** — The next semver is determined from the current version found in each package's version manifest (`package.json`, `version.json`, or `pyproject.toml`) using conventional-commit rules.
 5. **Output** — Azure DevOps `##vso[task.setvariable]` lines are written to stdout for consumption by downstream pipeline steps.
@@ -34,9 +34,10 @@ npx enablement-build-monorepo-version@latest [flags]
 | `--try`                       | off                 | Dry-run mode. Prints what each operation **would** do without writing any files, creating tags, or modifying any manifests. Combine with any other flags to preview their effect.                                                                                                                      |
 | `--debug`                     | off                 | Verbose logging of hashes, comparisons, and version resolution.                                                                                                                                                                                                                                        |
 | `--children <dirs>`           | auto-detect         | Comma- or space-separated list of top-level directories to scan (e.g. `components,saas`). When omitted, directories are read from `pnpm-workspace.yaml` or `package.json` workspaces automatically. Falls back to `packages` if neither file is found.                                                 |
-| `--platform <name>`           | auto-detect         | Force the CI output format: `ado` (Azure DevOps) or `github` (GitHub Actions). Auto-detected from the presence of a `.github/` directory.                                                                                                                                                              |
+| `--exclude <dirs>`            | —                   | Comma- or space-separated list of top-level directories to drop from whichever list of children is in effect — auto-detected or from `--children` (e.g. auto-detect everything but skip `tools`).                                                                                                       |
+| `--platform <name>`           | `ado`               | Select the CI output format: `ado` (Azure DevOps) or `github` (GitHub Actions). |
 | `--prefixPath <path>`         | `./`                | Root path prepended to all file lookups. Useful when running from a different working directory.                                                                                                                                                                                                       |
-| `--hashFile <path>`           | auto-detect         | Path (relative to `prefixPath`) where hash state is stored between runs. Defaults to `.github/manifest.json` or `.cicd/manifest.json` when those files exist (hashes stored inside `cicd[packageName].hash`); falls back to `.github/hash.json` or `.cicd/hash.json` for legacy standalone hash files. |
+| `--hashFile <path>`           | `{configDir}/hash.json` | Path (relative to `prefixPath`) where hash state is stored between runs. Hashes are always read from and written to a `hash.json` file; if this points at a `manifest.json`, it is redirected to a sibling `hash.json` in that same directory, and only the `hash` property of each package is updated there — no other property is written. |
 | `--dependencies <path>`       | `dependencies.json` | Path to the NX-style dependency graph used for transitive change propagation. By default, manifest dependencies are used when `{configDir}/manifest.json` exists; passing this flag explicitly overrides that and forces file-based dependency input.                                                  |
 | `--hashExcludeFolders <list>` | see below           | Comma-separated folder names to skip when hashing.                                                                                                                                                                                                                                                     |
 | `--hashExcludeFiles <list>`   | see below           | Comma-separated file names to skip when hashing.                                                                                                                                                                                                                                                       |
@@ -78,9 +79,9 @@ Versions follow semver and are bumped based on the **current version** in the pa
 
 ## Pipeline variable output
 
-The output format is auto-detected from the presence of a `.github/` directory at the root. It can also be forced with `--platform ado` or `--platform github`.
+The output format is selected with `--platform`; it defaults to Azure DevOps. Pass `--platform github` for GitHub Actions output.
 
-### Azure DevOps (default when no `.github/` directory)
+### Azure DevOps (default)
 
 Variables are written to stdout using the `##vso` task command:
 
@@ -90,7 +91,7 @@ Variables are written to stdout using the `##vso` task command:
 ##vso[task.setvariable variable=components;isoutput=true]true
 ```
 
-### GitHub Actions (when `.github/` directory is present)
+### GitHub Actions (`--platform github`)
 
 Variables are written to the `$GITHUB_OUTPUT` file (falls back to stdout if the env var is not set):
 
@@ -208,9 +209,10 @@ The following scripts are injected (skipped if already present; `--children` str
 ```
 src/
 ├── index.mjs        CLI entry point and main() orchestration
-├── lib.mjs          Core logic (exported for testing)
-├── version.mjs      Semver bump logic
-└── folder-hash.mjs  Recursive folder hashing
+├── lib.mjs          Core logic (exported for testing); also re-exports
+│                    workspace detection, folder hashing, and hash.json
+│                    handling from the enablement-build-manifest package
+└── version.mjs      Semver bump logic
 
 tests/
 ├── lib.test.mjs     Unit tests for lib.mjs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enablement-build-monorepo-version",
-  "version": "2.0.8",
+  "version": "6.0.0",
   "description": "This detects changes in the children packages of a monorepo.",
   "type": "module",
   "module": "./src/index.mjs",
@@ -14,7 +14,7 @@
     ]
   },
   "dependencies": {
-    "minimatch": "~10.1.1"
+    "enablement-build-manifest": "1.4.0"
   },
   "devDependencies": {
     "jest": "^30.4.2"

package/src/index.mjs

@@ -3,66 +3,9 @@ import path from 'path';
 import { readFileSync, writeFileSync, existsSync, lstatSync } from "fs";
 import { exec } from "child_process";
 
-import { hashElement } from "./folder-hash.mjs";
-import { dependencyMap, compare, getCurrentVersion, updateVersion, retagToPackageNames, detectOldFormatTags, resolveWorkspaceChildren, applyInitScripts, RELEASE_SCRIPTS, emitVariable } from "./lib.mjs";
+import { dependencyMap, compare, getCurrentVersion, updateVersion, retagToPackageNames, detectOldFormatTags, resolveWorkspaceChildren, excludeChildren, applyInitScripts, RELEASE_SCRIPTS, emitVariable, hashElement, resolveHashFilePath, ensureHashFileExists, loadHashFile, writeHashFile } from "./lib.mjs";
 
 
-// ─── Hash Format Conversion Helpers ──────────────────────────────────────────
-
-// Convert old hash.json format (keyed by shortName) to new nested structure (keyed by fullName)
-function convertOldHashFormat(oldHashData) {
-  const result = {};
-  Object.keys(oldHashData).forEach(shortName => {
-    const entry = oldHashData[shortName];
-    if (entry.fullName) {
-      result[entry.fullName] = {
-        hash: entry.hash,
-        version: entry.version
-      };
-    }
-  });
-  return result;
-}
-
-// Convert current hashes to structure for cicd property
-function buildHashesForCicd(current) {
-  const hashData = {};
-  const versions = {};
-
-  Object.keys(current).forEach(shortName => {
-    const entry = current[shortName];
-    if (entry.fullName) {
-      hashData[entry.fullName] = {
-        hash: entry.hash,
-        version: entry.version,
-        name: entry.fullName,
-        packageFolder: entry.packageFolder
-      };
-      versions[entry.fullName] = entry.version;
-    }
-  });
-
-  return { hashData, versions };
-}
-
-// Extract hashes from manifest.json (from cicd property) keyed by fullName
-function extractHashesFromManifestByFullName(manifest) {
-  const result = {};
-
-  if (manifest.cicd) {
-    Object.keys(manifest.cicd).forEach(fullname => {
-      if (manifest.cicd[fullname].hash) {
-        result[fullname] = {
-          hash: manifest.cicd[fullname].hash,
-          version: manifest.versions ? manifest.versions[fullname] : manifest.cicd[fullname].version
-        };
-      }
-    });
-  }
-
-  return result;
-}
-
 function bumpPatchVersion(version) {
   const value = (version || '0.0.0').trim();
   const parts = value.split('-');
@@ -120,21 +63,24 @@ async function main(options) {
       }
     }
 
+    // --exclude drops specific root directories from whichever children list
+    // is in effect, auto-detected or explicit.
+    if (options.exclude.length > 0) {
+      options.children = excludeChildren(options.children, options.exclude) || options.children;
+    }
+
     if (options.try) {
       console.log('\x1b[36m%s\x1b[0m', '[try] Dry-run mode — no changes will be made\n');
     }
 
-    const changeConfig = path.join(options.prefixPath, options.hashFile);
+    // Hashes are always stored in a hash.json file. When --hashFile points at a
+    // manifest.json (legacy "manifest mode"), redirect to the sibling hash.json
+    // instead of writing hash data into the manifest.
+    const { changeConfig, usesManifestHashFile } = resolveHashFilePath(options.prefixPath, options.hashFile);
     let previous = {};
 
-    // make sure hash config file exists only when using a dedicated hash.json file
-    if (!usesManifestHashFile && !existsSync(changeConfig)) {
-      if (options.try) {
-        console.log('\x1b[36m%s\x1b[0m', `[try] Hash file ${changeConfig} not found — treating previous state as empty`);
-      } else {
-        writeFileSync(changeConfig, "{}", "utf8");
-      }
-    }
+    // make sure hash config file exists
+    ensureHashFileExists(changeConfig, options);
 
     let dependencies = {};
 
@@ -155,16 +101,8 @@ async function main(options) {
       }
     }
 
-    // Load manifest for later use (will extract hashes after building current)
-    let manifestData = {};
-    if (usesManifestHashFile) {
-      const data = existsSync(changeConfig) ? readFileSync(changeConfig, "utf8") : "{}";
-      manifestData = JSON.parse(data || "{}");
-    }
-
-    // For now, set previous to empty - will populate after building current
-    // (because we need the fullName mapping from current)
-    previous = {};
+    // Load previous hashes, keyed by short package folder name.
+    previous = loadHashFile(changeConfig);
     if (options.debug) console.log("PREVIOUS", JSON.stringify(previous));
 
     options.hashFiles.forEach(file => {
@@ -205,21 +143,7 @@ async function main(options) {
           }
 
           if (options.changed || options.version || options.tag) {
-            // Build previous hashes keyed by short name using fullName mapping
-            let previousHashes = {};
-            if (usesManifestHashFile) {
-              const hashesByFullName = extractHashesFromManifestByFullName(manifestData);
-              Object.keys(current).forEach(shortName => {
-                const entry = current[shortName];
-                if (entry.fullName && hashesByFullName[entry.fullName]) {
-                  previousHashes[shortName] = hashesByFullName[entry.fullName];
-                }
-              });
-            } else {
-              previousHashes = previous;
-            }
-
-            let results = await compare(packageFolder, previousHashes, current, dependencies, options);
+            let results = await compare(packageFolder, previous, current, dependencies, options);
             if (options.debug) console.log("COMPARE", JSON.stringify(results));
 
             for (let i = 0; i < results.length; i++) {
@@ -308,39 +232,8 @@ async function main(options) {
       if (options.hash) {
         if (options.try) {
           console.log('\x1b[36m%s\x1b[0m', `[try] Would write updated hashes to ${changeConfig}`);
-        } else if (usesManifestHashFile) {
-          const manifestData = existsSync(changeConfig) ? readFileSync(changeConfig, "utf8") : "{}";
-          const manifest = JSON.parse(manifestData || "{}");
-
-          const { hashData, versions } = buildHashesForCicd(current);
-
-          // Update cicd properties with hash and metadata
-          Object.keys(hashData).forEach(fullname => {
-            if (!manifest.cicd) manifest.cicd = {};
-            if (!manifest.cicd[fullname]) manifest.cicd[fullname] = {};
-            manifest.cicd[fullname].hash = hashData[fullname].hash;
-            manifest.cicd[fullname].name = hashData[fullname].name;
-            delete manifest.cicd[fullname].folderName;
-            manifest.cicd[fullname].packageFolder = hashData[fullname].packageFolder;
-          });
-
-          // Update versions section
-          if (!manifest.versions) manifest.versions = {};
-          Object.keys(versions).forEach(fullname => {
-            manifest.versions[fullname] = versions[fullname];
-          });
-
-          // Remove old hash property if it exists
-          delete manifest.hash;
-
-          writeFileSync(changeConfig, JSON.stringify(manifest, null, 2), "utf8");
-          console.log('manifest hashes written successfully');
         } else {
-          let result = Object.keys(current).sort().reduce(
-            (obj, key) => { obj[key] = current[key]; return obj; },
-            {}
-          );
-          writeFileSync(changeConfig, JSON.stringify(result, null, 2), "utf8");
+          writeHashFile(changeConfig, current, { usesManifestHashFile });
           console.log('folder hashes written successfully');
         }
       }
@@ -396,7 +289,8 @@ let options = {
   try: false,
   commit: false,
   children: null,
-  platform: null,
+  exclude: [],
+  platform: 'ado',
   hashFiles: [],
   prefixPath: './',
   debug: false,
@@ -422,9 +316,9 @@ if (process.argv.length === 2) {
     else if (argv[i] === "--retag") options.retag = true;
     else if (argv[i] === "--init") options.init = true;
     else if (argv[i] === "--try") options.try = true;
-    else if (argv[i] === "--hashExcludeFolders" || argv[i] === "--hashExcludeFiles") {
+    else if (argv[i] === "--exclude" || argv[i] === "--hashExcludeFolders" || argv[i] === "--hashExcludeFiles") {
       let name = argv[i].substring(2);
-      options[name] = argv[i + 1].split(',');
+      options[name] = argv[i + 1].replace(/\s/g, ',').split(',');
       i++;
     }
     else if (argv[i] === "--hashFiles") {
@@ -445,25 +339,12 @@ if (process.argv.length === 2) {
   }
 }
 
-const hasGitHubManifest = existsSync(path.join(options.prefixPath, '.github/manifest.json'));
-const hasAdoManifest = existsSync(path.join(options.prefixPath, '.cicd/manifest.json'));
-const hasGitHubHash = existsSync(path.join(options.prefixPath, '.github/hash.json'));
 
-const configDir = (hasGitHubManifest || hasGitHubHash) ? '.github' : '.cicd';
+const configDir = options.platform === 'github' ? '.github' : '.cicd';
 if (!options.hashFile) {
-  if (configDir === '.github' && hasGitHubManifest) {
-    options.hashFile = '.github/manifest.json';
-  } else if (configDir === '.cicd' && hasAdoManifest) {
-    options.hashFile = '.cicd/manifest.json';
-  } else {
-    options.hashFile = configDir + '/hash.json';
-  }
+  options.hashFile = configDir + "/hash.json";
 }
-const usesManifestHashFile = options.hashFile.replace(/\\/g, '/').endsWith('/manifest.json');
 
-if (!options.platform) {
-  options.platform = configDir === '.github' ? 'github' : 'ado';
-}
 
 async function initPackage(options) {
   const pkgFile = path.join(options.prefixPath, 'package.json');

package/src/lib.mjs

@@ -9,78 +9,25 @@ import {
 import { exec } from "child_process";
 import { Version } from "./version.mjs";
 
-// ─── Workspace child-directory resolution ────────────────────────────────────
-
-// Parse the packages list from a pnpm-workspace.yaml string.
-export function parseWorkspacePatterns(content) {
-  const patterns = [];
-  let inPackages = false;
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (/^packages\s*:/.test(trimmed)) {
-      inPackages = true;
-      continue;
-    }
-    if (inPackages) {
-      if (trimmed.startsWith("-")) {
-        const value = trimmed
-          .slice(1)
-          .trim()
-          .replace(/^['"]|['"]$/g, "");
-        if (value) patterns.push(value);
-      } else if (trimmed && !/^\s/.test(line)) {
-        inPackages = false;
-      }
-    }
-  }
-  return patterns;
-}
-
-// Extract unique top-level directory names from workspace glob patterns.
-// e.g. ['packages/*', 'apps/**'] → ['packages', 'apps']
-export function extractDirsFromPatterns(patterns) {
-  const dirs = new Set();
-  for (const pattern of patterns) {
-    const dir = pattern
-      .split("/")[0]
-      .replace(/[*?[\]{}]/g, "")
-      .trim();
-    if (dir) dirs.add(dir);
-  }
-  return [...dirs];
-}
-
-// Read pnpm-workspace.yaml or package.json workspaces and return a
-// comma-separated string of top-level directories, or null if not found.
-export function resolveWorkspaceChildren(prefixPath) {
-  const pnpmFile = path.join(prefixPath, "pnpm-workspace.yaml");
-  if (existsSync(pnpmFile)) {
-    try {
-      const patterns = parseWorkspacePatterns(readFileSync(pnpmFile, "utf8"));
-      const dirs = extractDirsFromPatterns(patterns);
-      if (dirs.length > 0) return dirs.join(",");
-    } catch {}
-  }
-
-  const pkgFile = path.join(prefixPath, "package.json");
-  if (existsSync(pkgFile)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgFile, "utf8"));
-      if (pkg.workspaces) {
-        const ws = pkg.workspaces;
-        const patterns = Array.isArray(ws)
-          ? ws
-          : Array.isArray(ws?.packages)
-            ? ws.packages
-            : [];
-        const dirs = extractDirsFromPatterns(patterns);
-        if (dirs.length > 0) return dirs.join(",");
-      }
-    } catch {}
-  }
-
-  return null;
-}
+// Workspace child-directory resolution lives in the manifest package (it also
+// needs to know package roots) and is re-exported here so callers of this
+// module don't need to know that.
+export {
+  parseWorkspacePatterns,
+  extractDirsFromPatterns,
+  resolveWorkspaceChildren,
+  excludeChildren,
+} from "enablement-build-manifest/src/workspace.mjs";
+
+// Folder hashing (the recursive hash engine) and hash.json file handling both
+// live in the manifest package too, re-exported here for the same reason.
+export {
+  hashElement,
+  resolveHashFilePath,
+  ensureHashFileExists,
+  loadHashFile,
+  writeHashFile,
+} from "enablement-build-manifest/src/hashFile.mjs";
 
 // ─── pyproject.toml version read/write ───────────────────────────────────────
 

package/src/version.mjs

@@ -1,100 +1,183 @@
 import * as url from 'url';
 import fs from "fs";
-import { exec } from "child_process";
+import { execSync } 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('.');
+function getBumpType(message) {
+    const text = (message || "").trim();
+    if (!text) return "patch";
+
+    // Breaking change markers take precedence over all other commit types.
+    if (/BREAKING\s+CHANGES?:/im.test(text)) return "major";
+    if (/^\s*[a-z]+(?:\([^\n\r)]*\))?!:/im.test(text)) return "major";
+
+    const headers = text
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => line.trim())
+        .filter((line) => /^[a-z]+(?:\([^\n\r)]*\))?!?:/i.test(line));
+
+    const hasType = (types) => headers.some((line) => {
+        const match = line.match(/^([a-z]+)(?:\([^\n\r)]*\))?!?:/i);
+        return match ? types.includes(match[1].toLowerCase()) : false;
+    });
+
+    if (hasType(["feat", "refactor"])) return "minor";
+    if (hasType(["fix", "perf", "revert", "chore", "docs", "style", "test", "build", "ci"])) return "patch";
+
+    // Keep current behavior conservative when type is unknown.
+    return "patch";
+}
+
+function processMessage(message, tag, imageName, options, args) {
+    const previous = tag;
+    let normalizedTag = tag;
+
+    const atParts = normalizedTag.split('@');
+    if (atParts.length > 1) normalizedTag = atParts[1];
+
+    const suffixParts = normalizedTag.trim().split('-');
+    let suffix = false;
+    if (suffixParts.length > 1) {
+        normalizedTag = suffixParts[0];
+        suffix = suffixParts.slice(1).join('-');
+    }
+
+    const parts = normalizedTag.trim().split('.');
     parts.length = 3;
-    let build = false;
 
-    console.log("PROCESS -",imageName,tag,message)
+    let major = Number.parseInt(parts[0] || '0', 10) || 0;
+    let minor = Number.parseInt(parts[1] || '0', 10) || 0;
+    let patch = Number.parseInt(parts[2] || '0', 10) || 0;
 
-    if (message.indexOf("fix:") >= 0 || message==='') {
-        parts[2] = parseInt(parts[2]);
-        parts[2]++;
+    const bump = getBumpType(message);
+    let build = false;
+
+    if (bump === "major") {
+        major += 1;
+        minor = 0;
+        patch = 0;
         build = true;
-    }
-    if (message.indexOf("feat:") >= 0) {
-        parts[1] = parseInt(parts[1]);
-        parts[1]++;
-        parts[2] = 0;
+    } else if (bump === "minor") {
+        minor += 1;
+        patch = 0;
         build = true;
-    }
-    if (message.indexOf("BREAKING") >= 0) {
-        parts[0] = parseInt(parts[0]);
-        parts[0]++;
-        parts[1] = '0';
-        parts[2] = '0';
+    } else {
+        patch += 1;
         build = true;
     }
 
-    tag = parts.join('.');
-    if(suffix) tag=tag+'-'+suffix;
+    normalizedTag = `${major}.${minor}.${patch}`;
+    if (suffix) normalizedTag = `${normalizedTag}-${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};
-};
+    if (options.debug) {
+        console.log('\x1b[32m%s\x1b[0m', `Bump type: ${bump}`);
+        console.log('\x1b[32m%s\x1b[0m', `Next version: ${imageName}@${normalizedTag}`);
+    }
 
-async function Version(imageName, last_version, version_file, options, args)
-{
+    return { name: imageName, tag: normalizedTag, version: normalizedTag, build, previous, ...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;
-            if (version_file.endsWith('.toml')) {
-                let inSection = false;
-                for (const line of data.split('\n')) {
-                    const t = line.trim();
-                    if (/^\[project\]$/.test(t) || /^\[tool\.poetry\]$/.test(t)) { inSection = true; continue; }
-                    if (/^\[/.test(t)) { inSection = false; continue; }
-                    if (inSection) { const m = t.match(/^version\s*=\s*["']([^"']+)["']/); if (m) { tag = m[1]; break; } }
-                }
-            } else {
-                tag = JSON.parse(data).version;
+function readVersionTag(versionFile) {
+    const data = fs.readFileSync(versionFile, 'utf8');
+
+    if (versionFile.endsWith('.toml')) {
+        let inSection = false;
+        for (const line of data.split('\n')) {
+            const t = line.trim();
+            if (/^\[project\]$/.test(t) || /^\[tool\.poetry\]$/.test(t)) {
+                inSection = true;
+                continue;
+            }
+            if (/^\[/.test(t)) {
+                inSection = false;
+                continue;
+            }
+            if (inSection) {
+                const m = t.match(/^version\s*=\s*["']([^"']+)["']/);
+                if (m) return (m[1] || '0.0.0').trim();
             }
-            tag = (tag || '0.0.0').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));
+        }
+        return '0.0.0';
+    }
+
+    return (JSON.parse(data).version || '0.0.0').trim();
+}
+
+function findBaseTag(imageName, lastVersion) {
+    const shortName = String(imageName || '').split('/').pop();
+    const candidates = [
+        `${shortName}/${lastVersion}`,
+        `${imageName}/${lastVersion}`,
+        `${shortName}@${lastVersion}`,
+        `${imageName}@${lastVersion}`,
+        `v${lastVersion}`,
+        `${lastVersion}`
+    ].filter(Boolean);
+
+    for (const candidate of candidates) {
+        try {
+            execSync(`git rev-parse -q --verify "refs/tags/${candidate}"`, { stdio: 'ignore' });
+            return candidate;
         } 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});
+            // Try next tag format.
         }
-    };
-
-    // 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)
-    });
+    }
+
+    return null;
+}
+
+function readCommitMessagesSinceTag(imageName, lastVersion, args, options) {
+    const scopePath = args?.packageFolder && args?.name ? `${args.packageFolder}/${args.name}` : null;
+    const hasScope = scopePath && fs.existsSync(scopePath);
+
+    const baseTag = findBaseTag(imageName, lastVersion);
+    if (!baseTag) {
+        if (options.debug) {
+            console.log('\x1b[33m%s\x1b[0m', `No matching base tag found for ${imageName}@${lastVersion}; falling back to recent history.`);
+        }
+        const fallbackCmd = hasScope
+            ? `git log HEAD --pretty=%B --no-merges -- "${scopePath}"`
+            : `git log HEAD --pretty=%B --no-merges`;
+
+        try {
+            return execSync(fallbackCmd, { encoding: 'utf8' }).trim();
+        } catch {
+            return '';
+        }
+    }
+
+    const cmd = hasScope
+        ? `git log "${baseTag}..HEAD" --pretty=%B --no-merges -- "${scopePath}"`
+        : `git log "${baseTag}..HEAD" --pretty=%B --no-merges`;
+
+    if (options.debug) {
+        console.log('\x1b[32m%s\x1b[0m', `git log range: ${baseTag}..HEAD${hasScope ? ` (${scopePath})` : ''}`);
+    }
+
+    try {
+        return execSync(cmd, { encoding: 'utf8' }).trim();
+    } catch {
+        return '';
+    }
+}
+
+async function Version(imageName, lastVersion, versionFile, options, args) {
+    try {
+        if (options.debug) console.log('\x1b[32m%s\x1b[0m', `reading config: ${versionFile}`);
+        const tag = readVersionTag(versionFile);
+        if (options.debug) console.log('\x1b[32m%s\x1b[0m', `Found version: ${imageName}@${tag}`);
+
+        const message = args?.changed
+            ? readCommitMessagesSinceTag(imageName, lastVersion, args, options)
+            : '';
+
+        return processMessage(message, tag, imageName, options, args);
+    } catch {
+        if (options.debug) console.log('\x1b[33m%s\x1b[0m', 'Could not find last or next version: ');
+        return { name: imageName, tag: `${imageName}@0.0.0`, previous: '0.0.0', version: '0.0.1', ...args };
+    }
 }
 
-export { Version };
+export { Version, getBumpType, processMessage };

package/tests/index.test.mjs

@@ -0,0 +1,206 @@
+import { describe, it, expect } from "@jest/globals";
+import { execFileSync } from "child_process";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import {
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "fs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "..", "..");
+const cliPath = path.resolve(repoRoot, "monorepo-version", "src", "index.mjs");
+
+function setupWorkspace() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "monorepo-version-"));
+
+  mkdirSync(path.join(root, "packages", "example"), { recursive: true });
+  mkdirSync(path.join(root, ".cicd"), { recursive: true });
+
+  writeFileSync(
+    path.join(root, "package.json"),
+    JSON.stringify(
+      {
+        name: "tmp-monorepo",
+        private: true,
+        workspaces: ["packages/*"],
+      },
+      null,
+      2,
+    ) + "\n",
+    "utf8",
+  );
+
+  writeFileSync(
+    path.join(root, "packages", "example", "package.json"),
+    JSON.stringify(
+      {
+        name: "@scope/example",
+        version: "1.0.0",
+      },
+      null,
+      2,
+    ) + "\n",
+    "utf8",
+  );
+
+  writeFileSync(path.join(root, "packages", "example", "index.js"), "export default 1;\n", "utf8");
+
+  return root;
+}
+
+function runRelease(root, hashFile) {
+  const stdout = execFileSync(
+    "node",
+    [
+      cliPath,
+      "--hash",
+      "--changed",
+      "--children",
+      "packages",
+      "--prefixPath",
+      root,
+      "--hashFile",
+      hashFile,
+    ],
+    {
+      cwd: repoRoot,
+      encoding: "utf8",
+    },
+  );
+
+  const changedMatch = stdout.match(/CHANGED - (\[[^\n]*\])/);
+  if (!changedMatch) {
+    throw new Error(`Could not find changed list in output:\n${stdout}`);
+  }
+
+  return JSON.parse(changedMatch[1]);
+}
+
+describe("index CLI hash loading", () => {
+  it("supports non-manifest hash mode across repeated runs", () => {
+    const root = setupWorkspace();
+    try {
+      const first = runRelease(root, ".cicd/hash.json");
+      const second = runRelease(root, ".cicd/hash.json");
+
+      expect(first).toContain("example");
+      expect(second).toEqual([]);
+
+      const hashJson = JSON.parse(readFileSync(path.join(root, ".cicd", "hash.json"), "utf8"));
+      expect(hashJson.version).toBe(2);
+      expect(typeof hashJson.hash.example).toBe("string");
+      expect(hashJson.hash.example).toBeTruthy();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("redirects manifest hash mode to a sibling hash.json", () => {
+    const root = setupWorkspace();
+    try {
+      const first = runRelease(root, ".cicd/manifest.json");
+      const second = runRelease(root, ".cicd/manifest.json");
+
+      expect(first).toContain("example");
+      expect(second).toEqual([]);
+
+      const hashJson = JSON.parse(readFileSync(path.join(root, ".cicd", "hash.json"), "utf8"));
+      expect(hashJson.version).toBe(2);
+      expect(typeof hashJson.hash.example).toBe("string");
+      expect(hashJson.hash.example).toBeTruthy();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("index CLI --exclude", () => {
+  function setupWorkspaceWithTwoRoots() {
+    const root = mkdtempSync(path.join(os.tmpdir(), "monorepo-version-"));
+
+    mkdirSync(path.join(root, "packages", "example"), { recursive: true });
+    mkdirSync(path.join(root, "other-pkgs", "skip-me"), { recursive: true });
+    mkdirSync(path.join(root, ".cicd"), { recursive: true });
+
+    writeFileSync(
+      path.join(root, "package.json"),
+      JSON.stringify({ name: "tmp-monorepo", private: true, workspaces: ["packages/*", "other-pkgs/*"] }, null, 2) + "\n",
+      "utf8",
+    );
+
+    writeFileSync(
+      path.join(root, "packages", "example", "package.json"),
+      JSON.stringify({ name: "@scope/example", version: "1.0.0" }, null, 2) + "\n",
+      "utf8",
+    );
+    writeFileSync(
+      path.join(root, "other-pkgs", "skip-me", "package.json"),
+      JSON.stringify({ name: "@scope/skip-me", version: "1.0.0" }, null, 2) + "\n",
+      "utf8",
+    );
+
+    return root;
+  }
+
+  it("drops an auto-detected root directory from scanning", () => {
+    const root = setupWorkspaceWithTwoRoots();
+    try {
+      const stdout = execFileSync(
+        "node",
+        [cliPath, "--hash", "--changed", "--exclude", "other-pkgs", "--prefixPath", root],
+        { cwd: repoRoot, encoding: "utf8" },
+      );
+
+      const changedMatch = stdout.match(/CHANGED - (\[[^\n]*\])/);
+      const changed = JSON.parse(changedMatch[1]);
+
+      expect(changed).toContain("example");
+      expect(changed).not.toContain("skip-me");
+
+      const hashJson = JSON.parse(readFileSync(path.join(root, ".cicd", "hash.json"), "utf8"));
+      expect(hashJson.hash.example).toBeTruthy();
+      expect(hashJson.hash["skip-me"]).toBeUndefined();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("index CLI --children defaulting", () => {
+  it('falls back to scanning "packages" and warns when no workspace config exists and --children is omitted', () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), "monorepo-version-"));
+    try {
+      mkdirSync(path.join(root, "packages", "example"), { recursive: true });
+      mkdirSync(path.join(root, ".cicd"), { recursive: true });
+      // Deliberately no pnpm-workspace.yaml and no root package.json at all.
+
+      writeFileSync(
+        path.join(root, "packages", "example", "package.json"),
+        JSON.stringify({ name: "@scope/example", version: "1.0.0" }, null, 2) + "\n",
+        "utf8",
+      );
+
+      const stdout = execFileSync(
+        "node",
+        [cliPath, "--hash", "--changed", "--prefixPath", root],
+        { cwd: repoRoot, encoding: "utf8" },
+      );
+
+      expect(stdout).toContain('defaulting --children to "packages"');
+
+      const changedMatch = stdout.match(/CHANGED - (\[[^\n]*\])/);
+      expect(JSON.parse(changedMatch[1])).toContain("example");
+
+      const hashJson = JSON.parse(readFileSync(path.join(root, ".cicd", "hash.json"), "utf8"));
+      expect(hashJson.hash.example).toBeTruthy();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/tests/version.test.mjs

@@ -0,0 +1,34 @@
+import { describe, it, expect } from '@jest/globals';
+import { getBumpType, processMessage } from '../src/version.mjs';
+
+describe('version bump parsing', () => {
+  const options = { debug: false };
+
+  it('treats feat as minor', () => {
+    const result = processMessage('feat: add endpoint', '1.2.3', 'pkg', options, {});
+    expect(result.version).toBe('1.3.0');
+  });
+
+  it('treats refactor as minor', () => {
+    const result = processMessage('refactor: simplify auth flow', '1.2.3', 'pkg', options, {});
+    expect(result.version).toBe('1.3.0');
+  });
+
+  it('treats BREAKING CHANGES footer as major with precedence', () => {
+    const message = 'feat: redesign auth\n\nBREAKING CHANGES: removes legacy token format';
+    const result = processMessage(message, '1.2.3', 'pkg', options, {});
+    expect(result.version).toBe('2.0.0');
+  });
+
+  it('treats ! conventional commit marker as major', () => {
+    const result = processMessage('feat!: remove old API', '1.2.3', 'pkg', options, {});
+    expect(result.version).toBe('2.0.0');
+  });
+
+  it('classifies bump types directly', () => {
+    expect(getBumpType('feat(parser): support x')).toBe('minor');
+    expect(getBumpType('refactor(core): split module')).toBe('minor');
+    expect(getBumpType('fix: adjust typo')).toBe('patch');
+    expect(getBumpType('feat!: breaking')).toBe('major');
+  });
+});

package/src/folder-hash.mjs

@@ -1,425 +0,0 @@
-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
-};