enablement-build-manifest 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 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,87 @@
+# enablement-build-manifest
+
+Scans a monorepo and produces a JSON manifest describing every package's version, local dependency graph, and CI/CD metadata. Supports both Azure DevOps (`.cicd/`) and GitHub Actions (`.github/`) layouts.
+
+## Usage
+
+```sh
+npx enablement-build-manifest [options]
+```
+
+Run from the root of your monorepo. The manifest is printed to stdout and optionally saved to disk.
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--save` | Write the manifest to `{configDir}/manifest.json` in addition to stdout |
+| `--platform <github\|ado>` | Override platform detection (default: auto-detected) |
+| `--debug` | Print the number of discovered packages |
+
+## Platform Detection
+
+The platform is auto-detected by looking for the following files:
+
+- `.github/templates/templated.json` or `.github/manifest.json` → `github` (uses `.github/`)
+- Neither found → `ado` (uses `.cicd/`)
+
+Pass `--platform github` or `--platform ado` to override.
+
+## Output
+
+The manifest is a JSON object with five top-level keys:
+
+```json
+{
+  "versions":     { "<package-name>": "<version>", ... },
+  "dependencies": { "<package-name>": ["<local-dep>", ...], ... },
+  "dependents":   { "<package-name>": ["<consumer>", ...], ... },
+  "pipelines":    { "<template-file>": [ <stage>, ... ], ... },
+  "cicd":         { "<package-name>": { "output": "...", "language": "...", "tier": "...", ... }, ... }
+}
+```
+
+### `versions`
+
+Maps every local package name to its current version from `package.json`.
+
+### `dependencies` / `dependents`
+
+- `dependencies` — the local packages each package directly depends on.
+- `dependents` — the reverse: which local packages consume a given package.
+
+### `pipelines`
+
+Populated when `{configDir}/templates/templated.json` exists. Each key is a pipeline template filename; the value is an ordered list of resolved stages with their associated package lists.
+
+### `cicd`
+
+CI/CD metadata for each package. Sourced from the `.cicd` field in `package.json` when present; otherwise auto-detected by inspecting the package:
+
+| Indicator | `output` | `language` | `tier` |
+|-----------|----------|------------|--------|
+| `main` or `module` field | `npm` | `JavaScript` | `component` |
+| `bin` field (CLI tool) | `npm` | `JavaScript` | `tooling` |
+| `moleculer` dependency | `npm` | `node` | `api` |
+| `react` dependency | `npm` | `JavaScript` | `ux` |
+| `*.csproj` present | `nuget` | `C#` | `api` |
+| `pyproject.toml` present | `pypi` | `Python` | `api` |
+| `Dockerfile` in image/container path | `docker` | `Dockerfile` | `infra` |
+
+Template filenames are also resolved and attached to each `cicd` entry based on the package type.
+
+## Example
+
+```sh
+# Print manifest to stdout
+npx enablement-build-manifest
+
+# Save to .cicd/manifest.json (ADO project)
+npx enablement-build-manifest --save
+
+# Save to .github/manifest.json (GitHub project)
+npx enablement-build-manifest --save --platform github
+
+# Debug: show discovered package count
+npx enablement-build-manifest --debug
+```

package/index.mjs

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import { glob } from 'glob';
+import YAML from 'yaml'
+import path from 'path';
+
+const main = async (options) => {
+
+  if (!options.platform) {
+    options.platform = (fs.existsSync('.github/templates/templated.json') || fs.existsSync('.github/manifest.json')) ? 'github' : 'ado';
+  }
+  const configDir = options.platform === 'github' ? '.github' : '.cicd';
+
+  // Find all package.json files, excluding node_modules
+  const packageJsonPaths = glob.sync('*/**/package.json', {
+    ignore: ['**/node_modules/**'],
+    cwd: process.cwd(),
+    absolute: true
+  });
+
+  const nameToPath = {};
+
+  const versions = {};
+  const dependencies = {};
+  const dependents = {};
+  const cicd = {};
+  const pipelines = {};
+
+  const packageData = {};
+  const stage2Packages = {};
+
+  // First pass: collect all local package names and versions
+  packageJsonPaths.forEach(pkgPath => {
+    const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    packageData[pkgPath] = pkgJson;
+    if (pkgJson.name && pkgJson.version) {
+      nameToPath[pkgJson.name] = pkgPath;
+
+      // create map of stage to packages
+      const stageName = path.basename(path.dirname(path.dirname(pkgPath)));
+      if(!stage2Packages[stageName]) stage2Packages[stageName] = [];
+      stage2Packages[stageName].push(pkgJson.name);
+
+      versions[pkgJson.name] = pkgJson.version;
+      dependents[pkgJson.name] = []; // Initialize reverse dependency map
+      if (pkgJson['.cicd']) {
+        cicd[pkgJson.name] = pkgJson['.cicd'];
+      }
+    }
+  });
+
+  if(options.debug)
+    console.log(`Discovered ${Object.keys(nameToPath).length} local packages.`);
+
+
+  // Second pass: build dependency tree
+  Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
+    const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const allDeps = {
+      ...pkgJson.dependencies,
+      ...pkgJson.devDependencies
+    };
+
+    const localDeps = Object.keys(allDeps || {}).filter(dep => nameToPath.hasOwnProperty(dep));
+    dependencies[pkgName] = localDeps;
+
+    // Populate reverse dependencies
+    localDeps.forEach(dep => {
+      if (!dependents[dep]) {
+        dependents[dep] = [];
+      }
+      dependents[dep].push(pkgName);
+    });
+  });
+
+  // now find all packages that do not have a .cicd entry
+  Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
+    if (!cicd[pkgName]) {
+
+      var pkg = packageData[pkgPath];
+      if (pkg['main'] || pkg['module']) {
+        cicd[pkgName] = {
+          output: "npm",
+          language: 'JavaScript',
+          tier: 'component'
+        }
+        if(pkg["bin"]) {
+          cicd[pkgName]["packageType"] = "cli";
+          cicd[pkgName]["tier"] = "tooling";
+        }
+        return;
+      } else {
+        if ((pkg['devDependencies'] && pkg['devDependencies']['moleculer']) || (pkg['dependencies'] && pkg['dependencies']['moleculer'])) {
+          cicd[pkgName] = {
+            "output": "npm",
+            "language": "node",
+            "packageType": "moleculer",
+            "tier": "api"
+          }
+          return;
+        } else if ((pkg['devDependencies'] && pkg['devDependencies']['react']) || (pkg['dependencies'] && pkg['dependencies']['react'])) {
+          cicd[pkgName] = {
+            "output": "npm",
+            "language": "JavaScript",
+            "packageType": "ux",
+            "tier": "ux"
+          }
+          return;
+        } else {
+          // ok it is not node
+          var folderName = path.dirname(pkgPath);
+          const csproj = glob.sync('*.csproj', { cwd: folderName, absolute: true });
+          const toml = glob.sync('pyproject.toml', { cwd: folderName, absolute: true });
+          const docker = glob.sync('Dockerfile', { cwd: folderName, absolute: true });
+
+          if (csproj.length > 0) {
+            cicd[pkgName] = {
+              "output": "nuget",
+              "language": "C#",
+              "packageType": "dotnet",
+              "tier": "api"
+            }
+            return;
+          } else if (toml.length > 0) {
+            cicd[pkgName] = {
+              "output": "pypi",
+              "language": "Python",
+              "tier": "api"
+            }
+            if (pkgName.toLocaleLowerCase().endsWith("api")) cicd[pkgName]["packageType"] = "pypi";
+            return;
+          } else if (docker.length > 0 && (pkgPath.indexOf("image") >= 0 || pkgPath.indexOf("container") >= 0)) {
+            cicd[pkgName] = {
+              "output": "docker",
+              "language": "Dockerfile",
+              "tier": "infra"
+            }
+            return;
+          }
+        }
+      }
+    }
+  });
+
+  // now find all packages where templates are missing
+  // first load the templated.json
+  let templated = {};
+  if (fs.existsSync(`./${configDir}/templates/templated.json`)) {
+    let data = JSON.parse(fs.readFileSync(`./${configDir}/templates/templated.json`, 'utf-8'));
+    let innerNames ={};
+    for (const outerKey in data) {
+      const innerObj = data[outerKey];
+      const innerKeys = Object.keys(innerObj);
+      innerKeys.forEach(innerKey =>{
+        let { rootPath, template } = innerObj[innerKey];
+        rootPath = rootPath.replace(/\/+$/,''); // remove trailing slash
+        rootPath = rootPath.replace(/\.\.\/+/g, ''); // remove leading ../
+
+        innerNames[innerKey] = rootPath;
+        templated[rootPath] = templated[rootPath] || [];
+        templated[rootPath].push(template);
+      });
+    }
+
+    for (const outerKey in data) {
+      if(!pipelines[outerKey]) {
+        let pipeline = pipelines[outerKey] = [];
+
+        let tpl = fs.readFileSync(`./${configDir}/templates/${outerKey}`, 'utf-8');
+
+        let i = 0;
+        for (const innerKey of Object.keys(innerNames)) {
+          const regex = new RegExp(`\\{\\s*${innerKey.toUpperCase()}\\s*\\}`, 'g');
+          if(i==0) tpl = tpl.replace(regex, `  blocks:\n  - ${innerKey.toUpperCase()}`);
+          else tpl = tpl.replace(regex, `  - ${innerKey.toUpperCase()}`);
+          i++;
+        }
+
+        var yaml = YAML.parse(tpl);
+        for(const s of Object.keys(yaml.stages))
+        {
+          let stage = yaml.stages[s];
+
+          let blocks = stage.blocks;
+          if(blocks) {
+            for(const b of blocks) {
+              let pgkList= stage2Packages[innerNames[b]];
+              if(pgkList) stage.packages = pgkList;
+            }
+          }
+
+          delete stage.blocks;
+          delete stage.jobs;
+          delete stage.variables;
+          pipeline.push(stage);
+        }
+      }
+    }
+  }
+
+  const templates = glob.sync(`./${configDir}/templates/*.yml`);
+  const withUnderscore = templates
+                          .filter(file => file.includes('_'))
+                          .map(file => path.basename(file));
+
+  const codeScan = withUnderscore.filter(file => file.includes('scan') || file.includes('check'));
+  const build = withUnderscore.filter(file => !file.includes('scan') && !file.includes('check'));
+
+  Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
+    if (cicd[pkgName] && !cicd[pkgName]["templates"]) {
+      const pkgDir = path.basename(path.dirname(path.dirname(pkgPath)));
+      if(templated[pkgDir]) {
+        cicd[pkgName]["templates"] = templated[pkgDir];
+      } else {
+        let lookfor="node";
+        if(cicd[pkgName]["output"]=="pypi") lookfor = "python";
+        if(cicd[pkgName]["output"]=="nuget") lookfor = "dotnet";
+        if(cicd[pkgName]["output"]=="docker") lookfor = "docker";
+
+        let templates=[];
+        build.forEach(file => {
+          if (file.includes(lookfor) ) {
+            templates.push(file);
+          }
+        });
+        let found = false;
+        codeScan.forEach(file => {
+          if (file.includes(lookfor) ) {
+            templates.push(file);
+            found = true;
+          }
+        });
+        if(!found && templates.length>0) templates.push("build_scan.yml");
+        cicd[pkgName]["templates"] = templates;
+      }
+    }
+  });
+
+  // Final output structure
+  const output = {
+    versions,
+    dependencies,
+    dependents,
+    pipelines,
+    cicd
+  };
+
+  const outputJson = JSON.stringify(output, null, 2)
+  if(options.save) fs.writeFileSync(`./${configDir}/manifest.json`, outputJson, 'utf-8');
+  return outputJson;
+};
+
+let options = {
+    debug:false,
+    platform:null,
+    hashExcludeFolders:['node_modules', 'coverage', 'dist'],
+    hashExcludeFiles:['.npmrc','CHANGELOG.md','README.md']
+};
+
+// 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.save=true;
+    else if(argv[i]==="--debug") options.debug=true;
+    else if(argv[i]==="--changed") options.changed=true;
+    else if(argv[i]==="--hash") options.hash=true;
+    else if(argv[i]==="--platform") { options.platform = argv[i+1]; i++; }
+    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,17 @@
+{
+  "name": "enablement-build-manifest",
+  "version": "1.0.0",
+  "description": "This builds a dependency tree.",
+  "type": "module",
+  "module": "./index.mjs",
+  "bin": "./index.mjs",
+  "license": "MIT",
+  "author": "Contributors",
+  "dependencies": {
+    "glob": "^11.0.3",
+    "yaml": "^2.8.1"
+  },
+  "scripts": {
+    "start": "node index.mjs"
+  }
+}