enablement-build-monorepo-version 2.0.4 → 2.0.5

package/README.md

@@ -13,8 +13,8 @@ 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 a saved state file (`.cicd/hash.json` by default).
-3. **Propagate** — Any package whose hash changed is marked `CHANGED`. All transitive dependents (read from `dependencies.json`) are also marked `CHANGED` via a breadth-first traversal.
+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.
+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.
 
@@ -36,8 +36,8 @@ npx enablement-build-monorepo-version@latest [flags]
 | `--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. |
 | `--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/hash.json` if a `.github/` directory exists at the root, otherwise `.cicd/hash.json`. |
-| `--dependencies <path>` | `dependencies.json` | Path to the NX-style dependency graph used for transitive change propagation. |
+| `--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. |
+| `--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. |
 | `--hashFiles <list>` | — | Comma-separated individual file paths to include in the hash state (outside of `children` folders). |
@@ -114,9 +114,11 @@ Consume them in a subsequent step with `${{ steps.<step-id>.outputs.<name> }}`.
 
 ---
 
-## `dependencies.json` format
+## Dependency Source
 
-The file must be an NX project graph export. The relevant section is `graph.dependencies`, where each key is a package name and its value is an array of `{ source, target }` edges:
+By default, transitive dependency propagation uses `dependencies` from `{configDir}/manifest.json` when that manifest exists.
+
+To force file-based dependency input, pass `--dependencies <path>`. The file must be an NX project graph export. The relevant section is `graph.dependencies`, where each key is a package name and its value is an array of `{ source, target }` edges:
 
 ```json
 {
@@ -161,6 +163,8 @@ To bump and persist the new versions back to `package.json`:
 npx enablement-build-monorepo-version --changed --version --save
 ```
 
+When `--changed --version --save` detects any changed package, the root `package.json` version is also bumped by a patch increment.
+
 To override the auto-detected directories, pass `--children` explicitly:
 
 ```bash

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "enablement-build-monorepo-version",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "This detects changes in the children packages of a monorepo.",
   "type": "module",
   "module": "./src/index.mjs",
-  "bin": "./src/index.mjs",
   "license": "MIT",
   "author": "Contributors",
   "jest": {
@@ -17,11 +16,14 @@
     "minimatch": "~10.1.1"
   },
   "devDependencies": {
-    "jest": "^29.0.0"
+    "jest": "^30.4.2"
   },
   "scripts": {
     "start": "node src/index.mjs",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch"
+  },
+  "bin": {
+    "enablement-build-monorepo-version": "./src/index.mjs"
   }
 }

package/src/index.mjs

@@ -7,6 +7,100 @@ import { hashElement } from "./folder-hash.mjs";
 import { dependencyMap, compare, getCurrentVersion, updateVersion, retagToPackageNames, detectOldFormatTags, resolveWorkspaceChildren, applyInitScripts, RELEASE_SCRIPTS, emitVariable } 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,
+        folderName: shortName,
+        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('-');
+  const base = parts[0] || '0.0.0';
+  const suffix = parts.length > 1 ? parts.slice(1).join('-') : '';
+
+  const nums = base.split('.');
+  const major = Number.parseInt(nums[0] || '0', 10) || 0;
+  const minor = Number.parseInt(nums[1] || '0', 10) || 0;
+  const patch = (Number.parseInt(nums[2] || '0', 10) || 0) + 1;
+
+  const next = `${major}.${minor}.${patch}`;
+  return suffix ? `${next}-${suffix}` : next;
+}
+
+async function updateRootVersionIfNeeded(options, changeList) {
+  if (!options.saveVersion || !options.version || changeList.length === 0) return;
+
+  const rootPackageFile = path.join(options.prefixPath, 'package.json');
+  if (!existsSync(rootPackageFile)) return;
+
+  const pkg = JSON.parse(readFileSync(rootPackageFile, 'utf8'));
+  const previous = pkg.version || '0.0.0';
+  const next = bumpPatchVersion(previous);
+
+  if (options.try) {
+    console.log('\x1b[36m%s\x1b[0m', `[try] Would update ${rootPackageFile} version ${previous} -> ${next}`);
+    return;
+  }
+
+  if (previous !== next) {
+    pkg.version = next;
+    writeFileSync(rootPackageFile, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+    console.log(`root package.json version updated: ${previous} -> ${next}`);
+  }
+}
+
+
 async function main(options) {
   return new Promise((mainResolve, mainreject) => {
     const hashOptions = { encoding: 'hex', folders: { exclude: options.hashExcludeFolders }, files: { exclude: options.hashExcludeFiles } };
@@ -33,8 +127,8 @@ async function main(options) {
     const changeConfig = path.join(options.prefixPath, options.hashFile);
     let previous = {};
 
-    // make sure hash config file exists
-    if (!existsSync(changeConfig)) {
+    // 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 {
@@ -43,7 +137,16 @@ async function main(options) {
     }
 
     let dependencies = {};
-    if (options.dependencies) {
+
+    const manifestDependencyPath = path.join(options.prefixPath, `${configDir}/manifest.json`);
+    const shouldPreferManifestDependencies = !options.dependenciesProvided && existsSync(manifestDependencyPath);
+
+    if (shouldPreferManifestDependencies) {
+      const manifestText = readFileSync(manifestDependencyPath, 'utf8');
+      const manifest = JSON.parse(manifestText || '{}');
+      dependencies = manifest.dependencies || {};
+      if (options.debug) console.log(`Loaded dependencies from ${manifestDependencyPath}\n`, JSON.stringify(dependencies));
+    } else if (options.dependencies) {
       if (existsSync(options.dependencies)) {
         dependencies = dependencyMap(options.dependencies);
         if (options.debug) console.log('Loaded dependencies\n', JSON.stringify(dependencies));
@@ -52,9 +155,16 @@ async function main(options) {
       }
     }
 
-    // load previous hashes
-    const data = existsSync(changeConfig) ? readFileSync(changeConfig, "utf8") : "{}";
-    previous = JSON.parse(data);
+    // 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 = {};
     if (options.debug) console.log("PREVIOUS", JSON.stringify(previous));
 
     options.hashFiles.forEach(file => {
@@ -95,7 +205,21 @@ async function main(options) {
           }
 
           if (options.changed || options.version || options.tag) {
-            let results = await compare(packageFolder, previous, current, dependencies, options);
+            // 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);
             if (options.debug) console.log("COMPARE", JSON.stringify(results));
 
             for (let i = 0; i < results.length; i++) {
@@ -164,7 +288,9 @@ async function main(options) {
       }));
     });
 
-    Promise.all(scanlist).then(() => {
+    Promise.all(scanlist).then(async () => {
+      await updateRootVersionIfNeeded(options, changeList);
+
       if (options.changed) {
         console.log(`CHANGED - ${JSON.stringify(changeList)}`);
         emitVariable('changed', JSON.stringify(changeList), options.platform);
@@ -180,13 +306,39 @@ async function main(options) {
 
       // write current hashes
       if (options.hash) {
-        let result = Object.keys(current).sort().reduce(
-          (obj, key) => { obj[key] = current[key]; return obj; },
-          {}
-        );
         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].folderName = hashData[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");
           console.log('folder hashes written successfully');
         }
@@ -250,7 +402,8 @@ let options = {
   hashFile: null,
   hashExcludeFolders: ['node_modules', 'coverage', 'dist', 'bin', 'obj', '__pycache__', '.vs', '.nx', '.vscode', '.idea', '.git', '.github', '.azuredevops', '.release'],
   hashExcludeFiles: ['.npmrc', 'CHANGELOG.md', 'README.md'],
-  dependencies: "dependencies.json"
+  dependencies: "dependencies.json",
+  dependenciesProvided: false
 };
 
 if (process.argv.length === 2) {
@@ -281,6 +434,7 @@ if (process.argv.length === 2) {
       let name = argv[i].substring(2);
       if (options[name] !== undefined) {
         options[name] = argv[i + 1];
+        if (name === 'dependencies') options.dependenciesProvided = true;
         i++;
       } else {
         console.error(`Expected a known option, got ${argv[i]}`);
@@ -290,12 +444,24 @@ if (process.argv.length === 2) {
   }
 }
 
-const hasGitHub = existsSync(path.join(options.prefixPath, '.github/hash.json'));
+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';
 if (!options.hashFile) {
-  options.hashFile = hasGitHub ? '.github/hash.json' : '.cicd/hash.json';
+  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';
+  }
 }
+const usesManifestHashFile = options.hashFile.replace(/\\/g, '/').endsWith('/manifest.json');
+
 if (!options.platform) {
-  options.platform = hasGitHub ? 'github' : 'ado';
+  options.platform = configDir === '.github' ? 'github' : 'ado';
 }
 
 async function initPackage(options) {