enablement-build-manifest 1.0.2 → 1.0.3

package/_context/build.yml

@@ -0,0 +1,336 @@
+trigger:
+- main
+
+parameters:
+- name: publish_ado
+  displayName: Publish ADO
+  type: boolean
+  default: true
+
+- name: publish_nexus
+  displayName: Publish Nexus
+  type: boolean
+  default: true
+
+pool:
+  name: On-Prem Build Agents
+  demands:
+  - Agent.OS -equals Linux
+
+resources:
+  repositories:
+    - repository: team
+      type: git
+      name: ECommerce/pipeline-templates
+variables:
+    publish_nexus: ${{parameters.publish_nexus}}
+    publish_ado: ${{parameters.publish_ado}}
+    isMain: $[eq(variables['Build.SourceBranch'], 'refs/heads/main')]
+    dockerRoot: deploy
+    PIPELINE_NAME: enable-deploy-mono.GH.DEPLOY
+
+stages:
+- stage: Version
+  jobs:
+    - job: CheckForChanges
+      steps:
+      - checkout: self
+        persistCredentials: true
+        fetchTags: true,
+        fetchDepth: 0,
+        clean: true
+      - script: |
+          REPO=$(echo $(Build.Repository.Name)| cut -d'/' -f 2)
+          echo "##vso[task.setvariable variable=repo;isoutput=true;]$REPO"
+          BRANCH=$(echo $(Build.SourceBranchName))
+          echo $REPO/$BRANCH
+          echo "##vso[task.setvariable variable=env;isoutput=true;]DEV"
+
+          git config --global user.email "icg_it_linux@ingramcontent.com"
+          git config --global user.name "CICD"
+
+          npm i pnpm@10 nx@latest jest -g
+          nx graph --file dependencies.json
+          git clean -dfX
+          npm run release:changed
+        displayName: 'Get Changes'
+        name: getChanged
+
+- stage: Build_Node
+  dependsOn: Version
+  displayName: Build Node
+  jobs:
+  - job: BuildChanged
+    pool:
+      name: 'On-Prem Build Agents'
+      demands:
+      - Agent.OS -equals Linux
+    timeoutInMinutes: 60
+    variables:
+      changed: $[stageDependencies.Version.CheckForChanges.outputs['getChanged.changed']]
+
+    steps:
+    - checkout: self
+      persistCredentials: true
+      fetchTags: true,
+      fetchDepth: 0,
+      clean: true
+    - script: |
+        echo $(changed)
+        cp ./.cicd/ado.npmrc ./.npmrc
+      displayName: 'ADO NPM Prepare'
+      condition: eq(variables.publish_ado, true)
+    - task: npmAuthenticate@0
+      inputs:
+        customEndpoint: 'ado-npm-icg,ado-npm-lit'
+        workingFile: ./.npmrc
+      displayName: 'ADO NPM Authentication'
+      condition: eq(variables.publish_ado, true)
+    - script: |
+        mv ./.npmrc ./.npmrc_ado
+      displayName: 'ADO NPM Save'
+      condition: eq(variables.publish_ado, true)
+
+    - script: |
+        cp ./.cicd/nexus.npmrc ./.npmrc
+      displayName: 'Nexus NPM Prepare'
+      condition: eq(variables.publish_nexus, true)
+    - task: npmAuthenticate@0
+      inputs:
+        customEndpoint: 'nexus-npm-hosted'
+        workingFile: ./.npmrc
+      displayName: 'Nexus NPM Authentication'
+      condition: eq(variables.publish_nexus, true)
+    - script: |
+        mv ./.npmrc ./.npmrc_nexus
+      displayName: 'Nexus NPM Save'
+      condition: eq(variables.publish_nexus, true)
+
+    - script: |
+        npm install -g nx pnpm@10
+        nx graph --file dependencies.json
+        npm run release:version
+      displayName: 'Get Versions'
+      name: getVersions
+
+    - script: |
+        cp ./.cicd/nexus-group.npmrc ./.npmrc
+        #rm -f pnpm-lock.yaml
+        pnpm i
+      name: INSTALL
+
+    - script: |
+        export NX_DISABLE_DB=true
+        pnpm run build
+      name: BUILD
+
+    - script: |
+        pnpm test
+      displayName: 'TEST'
+      name: tester
+
+    # - template: sonarqube-prepare.yml@team
+    #   parameters:
+    #     scannerMode: "other"
+
+    ####################PACKAGES
+{PACKAGES}
+    ####################PACKAGES
+
+    ####################API
+{API}
+    ####################API
+
+    ####################UX
+{UX}
+    ####################UX
+
+- stage: Build_Python
+  dependsOn: Version
+  displayName: Build Python
+  jobs:
+  - job: BuildChanged
+    pool:
+      name: 'On-Prem Build Agents'
+      demands:
+      - Agent.OS -equals Linux
+    timeoutInMinutes: 60
+    variables:
+      changed: $[stageDependencies.Version.CheckForChanges.outputs['getChanged.changed']]
+
+    steps:
+    - checkout: self
+      persistCredentials: true
+      fetchTags: true,
+      fetchDepth: 0,
+      clean: true
+
+    - script: |
+        npm install -g nx pnpm@10
+        nx graph --file dependencies.json
+        npm run release:version
+      displayName: 'Get Versions'
+      name: getVersions
+
+    # - script: |
+    #     export NX_DISABLE_DB=true
+    #     pnpm run build:python
+    #   name: BUILD
+
+    # - script: |
+    #     pnpm test:python
+    #   displayName: 'TEST'
+    #   name: tester
+
+    ####################PYTHON_PACKAGES
+{PYTHON_PACKAGES}
+    ####################PYTHON_PACKAGES
+
+    - task: CopyFiles@2
+      displayName: 'Copy Lock Files to Staging'
+      inputs:
+        SourceFolder: '$(System.DefaultWorkingDirectory)'
+        Contents: |
+          **/poetry.lock
+          **/requirements.txt
+          **/pyproject.toml
+        TargetFolder: '$(Build.ArtifactStagingDirectory)'
+
+    - task: PublishPipelineArtifact@1
+      displayName: 'Publish Python Lock Files'
+      inputs:
+        targetPath: '$(Build.ArtifactStagingDirectory)'
+        artifactName: 'python-lock-files'
+        publishLocation: 'pipeline'
+
+
+- stage: Build_DotNet
+  dependsOn: Version
+  displayName: Build DotNet
+  jobs:
+  - job: BuildChanged
+    pool:
+      name: 'On-Prem Build Agents'
+      demands:
+      - Agent.OS -equals Linux
+    timeoutInMinutes: 60
+    variables:
+      changed: $[stageDependencies.Version.CheckForChanges.outputs['getChanged.changed']]
+
+    steps:
+    - checkout: self
+      persistCredentials: true
+      fetchTags: true,
+      fetchDepth: 0,
+      clean: true
+
+    - script: |
+        npm install -g nx pnpm@10
+        nx graph --file dependencies.json
+        npm run release:version
+      displayName: 'Get Versions'
+      name: getVersions
+
+    ####################DOTNET_PACKAGES
+{DOTNET_PACKAGES}
+    ####################DOTNET_PACKAGES
+
+- stage: Build_Containers
+  dependsOn:
+    - Version
+    - Build_Python
+    - Build_Node
+    - Build_DotNet
+  displayName: Build Containers
+  jobs:
+  - job: BuildChanged
+    pool:
+      name: 'On-Prem Build Agents'
+      demands:
+      - Agent.OS -equals Linux
+    timeoutInMinutes: 60
+    variables:
+      changed: $[stageDependencies.Version.CheckForChanges.outputs['getChanged.changed']]
+
+    steps:
+    - checkout: self
+      persistCredentials: true
+      fetchTags: true,
+      fetchDepth: 0,
+      clean: true
+
+    - script: |
+        npm install -g nx pnpm@10
+        nx graph --file dependencies.json
+        npm run release:version
+      displayName: 'Get Versions'
+      name: getVersions
+
+    # - script: |
+    #     pnpm test
+    #   displayName: 'TEST'
+    #   name: tester
+
+    ####################CONTAINERS
+{CONTAINERS}
+    ####################CONTAINERS
+
+
+- stage: Release
+  dependsOn:
+    - Version
+    - Build_Containers
+    - Build_Python
+    - Build_Node
+    - Build_DotNet
+
+  variables:
+    VERSION: $[ stageDependencies.Version.CheckForChanges.outputs['getChanged.tag'] ]
+    REPO: $[ stageDependencies.Version.CheckForChanges.outputs['getChanged.repo'] ]
+    ENV: $[ stageDependencies.Version.CheckForChanges.outputs['getChanged.env'] ]
+    BRANCH: $(Build.SourceBranchName)
+  jobs:
+  - job: Push
+    condition: and(succeeded(), eq(variables.isMain, true))
+    steps:
+    - checkout: self
+      persistCredentials: true
+      fetchTags: true,
+      fetchDepth: 0,
+      clean: true
+    - script: |
+        git config --global user.email "icg_it_linux@ingramcontent.com"
+        git config --global user.name "CICD"
+
+        SHA=$(git rev-parse HEAD)
+        working=working$SHA
+        git checkout -b $working
+        git branch -D $BRANCH &>/dev/null || true
+        git checkout $BRANCH
+        git branch -D $working &>/dev/null || true
+
+        git clean -dfX
+      displayName: Prepare
+
+    - task: DownloadPipelineArtifact@2
+      displayName: 'Restore Python Files'
+      inputs:
+        artifactName: 'python-lock-files'
+        targetPath: '$(System.DefaultWorkingDirectory)'
+
+    - script: |
+        npm run release:version
+        npm run release:finalize
+        npx enablement-build-version-repo --version --debug --save $VERSION
+      displayName: Version
+
+    - script: |
+        git commit -am "chore(release): $VERSION" -m "[skip ci]" --no-verify
+        git push
+        git push --tags
+      displayName: Success
+
+    - template: steps/deploy-ado-pipeline.yml@team
+      parameters:
+        pipelineName: $(PIPELINE_NAME)
+        branch: $(BRANCH)

package/_context/templated.json

@@ -0,0 +1,48 @@
+{
+  "build.yml": {
+    "CONTAINERS": {
+      "rootPath": "../../containers",
+      "template": "build_docker_package.yml"
+    },
+    "CONTAINERS_CHECKMARX": {
+      "rootPath": "../../containers",
+      "template": "build_scan.yml"
+    },
+    "API": {
+      "rootPath": "../../api",
+      "template": "build_node_package.yml"
+    },
+    "PACKAGES": {
+      "rootPath": "../../packages",
+      "template": "build_node_component.yml"
+    },
+    "UX": {
+      "rootPath": "../../ux",
+      "template": "build_node_package.yml"
+    },
+    "CHECKMARX_UX": {
+      "rootPath": "../../ux",
+      "template": "build_scan_node.yml"
+    },
+    "CHECKMARX_API": {
+      "rootPath": "../../api",
+      "template": "build_scan_node.yml"
+    },
+    "PYTHON_PACKAGES": {
+      "rootPath":"../../python",
+      "template":"build_python_package.yml"
+    },
+    "PYTHON_CHECKMARX": {
+      "rootPath":"../../python",
+      "template":"build_scan.yml"
+    },
+    "DOTNET_PACKAGES": {
+      "rootPath":"../../dotnet",
+      "template":"build_dotnet_package.yml"
+    },
+    "DOTNET_CHECKMARX": {
+      "rootPath":"../../dotnet",
+      "template":"build_scan.yml"
+    }
+  }
+}

package/index.mjs

@@ -1,355 +1,5 @@
 #!/usr/bin/env node
 
-import fs from 'fs';
-import { globbySync } from 'globby';
-import YAML from 'yaml'
-import path from 'path';
+import { runCli } from './src/cli.mjs';
 
-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 = globbySync('*/**/package.json', {
-    ignore: ['**/node_modules/**', '**/tests/**'],
-    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
-      const folderName = path.basename(path.dirname(pkgPath));
-      const packageFolder = path.basename(path.dirname(path.dirname(pkgPath)));
-      if (pkgJson['.cicd']) {
-        const cicdEntry = { ...pkgJson['.cicd'] };
-        delete cicdEntry.templates;
-        cicdEntry.folderName = folderName;
-        cicdEntry.packageFolder = packageFolder;
-        cicd[pkgJson.name] = cicdEntry;
-      }
-      // Always ensure folderName/packageFolder are present if cicd entry exists
-      if (cicd[pkgJson.name]) {
-        if (!cicd[pkgJson.name].folderName) cicd[pkgJson.name].folderName = folderName;
-        if (!cicd[pkgJson.name].packageFolder) cicd[pkgJson.name].packageFolder = packageFolder;
-      }
-    }
-  });
-
-  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 = globbySync('*.csproj', { cwd: folderName, absolute: true });
-          const toml = globbySync('pyproject.toml', { cwd: folderName, absolute: true });
-          const docker = globbySync('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;
-          }
-        }
-      }
-    }
-  });
-
-  // Ensure folderName and packageFolder are set on every cicd entry
-  Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
-    if (cicd[pkgName]) {
-      if (!cicd[pkgName].folderName)
-        cicd[pkgName].folderName = path.basename(path.dirname(pkgPath));
-      if (!cicd[pkgName].packageFolder)
-        cicd[pkgName].packageFolder = path.basename(path.dirname(path.dirname(pkgPath)));
-    }
-  });
-
-  // now find all packages where templates are missing
-  // first load the templated.json
-  let templatedConfig = {};
-  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;
-        templatedConfig[rootPath] = templatedConfig[rootPath] || [];
-        templatedConfig[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:
-  - ${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 = globbySync(`./${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'));
-
-  // Load existing manifest to preserve any already-set templated values
-  const manifestPath = `./${configDir}/manifest.json`;
-  const existingManifest = fs.existsSync(manifestPath)
-    ? JSON.parse(fs.readFileSync(manifestPath, 'utf-8'))
-    : {};
-  const existingTemplated = existingManifest.templated || {};
-  const existingPackages = (existingTemplated["build.yml"] || {})["PACKAGES"] || {};
-  const existingCicd = existingManifest.cicd || {};
-
-  const templated = {
-    "build.yml": {
-      "PACKAGES": {}
-    }
-  };
-
-  Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
-    if (cicd[pkgName]) {
-      // Preserve any existing templated assignment for this package
-      if (existingPackages[pkgName] !== undefined) {
-        templated["build.yml"]["PACKAGES"][pkgName] = existingPackages[pkgName];
-        return;
-      }
-      const pkgDir = path.basename(path.dirname(path.dirname(pkgPath)));
-      if(templatedConfig[pkgDir]) {
-        templated["build.yml"]["PACKAGES"][pkgName] = templatedConfig[pkgDir].length === 1
-          ? templatedConfig[pkgDir][0]
-          : templatedConfig[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");
-        templated["build.yml"]["PACKAGES"][pkgName] = templates.length === 1 ? templates[0] : templates;
-      }
-    }
-  });
-
-  // Merge in any pre-existing cicd fields (hash, folderName, packageFolder set by release:finalize)
-  Object.keys(existingCicd).forEach(pkgName => {
-    if (cicd[pkgName]) {
-      // Preserve fields from the existing entry that we don't regenerate
-      if (existingCicd[pkgName].hash) cicd[pkgName].hash = existingCicd[pkgName].hash;
-      if (existingCicd[pkgName].version) cicd[pkgName].version = existingCicd[pkgName].version;
-    } else {
-      // If package was in cicd before but not now, preserve entire entry
-      cicd[pkgName] = existingCicd[pkgName];
-    }
-  });
-
-  // Final output structure
-  const output = {
-    versions,
-    dependencies,
-    dependents,
-    pipelines,
-    templated,
-    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);
-  }
-})();
+await runCli();

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "enablement-build-manifest",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "This builds a dependency tree.",
   "type": "module",
   "module": "./index.mjs",
+  "bin": "./index.mjs",
   "license": "MIT",
   "author": "Contributors",
   "dependencies": {
@@ -11,9 +12,7 @@
     "yaml": "^2.8.1"
   },
   "scripts": {
-    "start": "node index.mjs"
-  },
-  "bin": {
-    "enablement-build-manifest": "./index.mjs"
+    "start": "node index.mjs",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest tests/*.test.mjs"
   }
 }

package/src/cli.mjs

@@ -0,0 +1,13 @@
+import { generateManifest } from './manifest.mjs';
+import { parseCliArgs } from './options.mjs';
+
+export const runCli = async (argv = process.argv, log = console.log, exit = process.exit) => {
+  try {
+    const options = parseCliArgs(argv);
+    const text = await generateManifest(options);
+    log(text);
+  } catch (e) {
+    log(e);
+    exit(1);
+  }
+};

package/src/manifest.mjs

@@ -0,0 +1,402 @@
+import fs from 'fs';
+import { globbySync } from 'globby';
+import YAML from 'yaml'
+import path from 'path';
+
+export const generateManifest = 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 = globbySync('*/**/package.json', {
+    ignore: ['**/node_modules/**', '**/tests/**'],
+    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
+      const folderName = path.basename(path.dirname(pkgPath));
+      const packageFolder = path.basename(path.dirname(path.dirname(pkgPath)));
+      if (pkgJson['.cicd']) {
+        const cicdEntry = { ...pkgJson['.cicd'] };
+        delete cicdEntry.templates;
+        cicdEntry.folderName = folderName;
+        cicdEntry.packageFolder = packageFolder;
+        cicd[pkgJson.name] = cicdEntry;
+      }
+      // Always ensure folderName/packageFolder are present if cicd entry exists
+      if (cicd[pkgJson.name]) {
+        if (!cicd[pkgJson.name].folderName) cicd[pkgJson.name].folderName = folderName;
+        if (!cicd[pkgJson.name].packageFolder) cicd[pkgJson.name].packageFolder = packageFolder;
+      }
+    }
+  });
+
+  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 = globbySync('*.csproj', { cwd: folderName, absolute: true });
+          const toml = globbySync('pyproject.toml', { cwd: folderName, absolute: true });
+          const docker = globbySync('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;
+          }
+        }
+      }
+    }
+  });
+
+  // Ensure folderName and packageFolder are set on every cicd entry
+  Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
+    if (cicd[pkgName]) {
+      if (!cicd[pkgName].folderName)
+        cicd[pkgName].folderName = path.basename(path.dirname(pkgPath));
+      if (!cicd[pkgName].packageFolder)
+        cicd[pkgName].packageFolder = path.basename(path.dirname(path.dirname(pkgPath)));
+    }
+  });
+
+  // Build pipeline file list, placeholder map, and folder→entry map from templated.json.
+  // pipelineFiles: ["build.yml", ...]
+  // placeholderMap: { pipelineFile: { PLACEHOLDER: { template, folderName } } }
+  // folderToEntry: { folderName: { pipelineFile, placeholder, template } }
+  let pipelineFiles = [];
+  const placeholderMap = {};
+  const folderToEntry = {};
+  let templatedConfig = {}; // folderName → [templates], used by pipeline generation
+
+  const templatedJsonPath = `./${configDir}/templates/templated.json`;
+  if (fs.existsSync(templatedJsonPath)) {
+    let data = JSON.parse(fs.readFileSync(templatedJsonPath, 'utf-8'));
+    let innerNames = {};
+    for (const pipelineFile of Object.keys(data)) {
+      pipelineFiles.push(pipelineFile);
+      placeholderMap[pipelineFile] = {};
+      for (const [placeholder, entry] of Object.entries(data[pipelineFile])) {
+        let rootPath = entry.rootPath.replace(/\/+$/, '').replace(/\.\.\/+/g, '');
+        const tpl = entry.template;
+        placeholderMap[pipelineFile][placeholder] = { template: tpl, folderName: rootPath };
+        innerNames[placeholder] = rootPath;
+        templatedConfig[rootPath] = templatedConfig[rootPath] || [];
+        if (!templatedConfig[rootPath].includes(tpl)) templatedConfig[rootPath].push(tpl);
+        if (!folderToEntry[rootPath]) {
+          folderToEntry[rootPath] = { pipelineFile, placeholder, template: tpl };
+        }
+      }
+    }
+
+      for (const outerKey in data) {
+        if(!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++;
+          }
+
+          let yaml;
+          try {
+            yaml = YAML.parse(tpl);
+          } catch (e) {
+            if (options.debug) console.warn(`Skipping unparseable YAML template ${outerKey}: ${e.message}`);
+            continue;
+          }
+
+          let pipeline = pipelines[outerKey] = [];
+          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);
+          }
+        }
+      }
+  } else {
+    // Fallback: pipeline files = non-underscore .yml files in templates dir
+    const allTemplates = globbySync(`./${configDir}/templates/*.yml`);
+    pipelineFiles = allTemplates
+      .filter(f => !path.basename(f).includes('_'))
+      .map(f => path.basename(f));
+    // Placeholder keys = top-level children folder names uppercased
+    try {
+      const childrenFolders = fs.readdirSync('.').filter(f => {
+        try { return fs.statSync(f).isDirectory() && !f.startsWith('.') && f !== 'node_modules'; }
+        catch (e) { return false; }
+      });
+      for (const pipelineFile of pipelineFiles) {
+        placeholderMap[pipelineFile] = {};
+        for (const folder of childrenFolders) {
+          placeholderMap[pipelineFile][folder.toUpperCase()] = { template: null, folderName: folder };
+          if (!folderToEntry[folder]) {
+            folderToEntry[folder] = { pipelineFile, placeholder: folder.toUpperCase(), template: null };
+          }
+        }
+      }
+    } catch(e) {}
+  }
+
+  const templates = globbySync(`./${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'));
+
+  // Load existing manifest to preserve any already-set templated values
+  const manifestPath = `./${configDir}/manifest.json`;
+  const existingManifest = fs.existsSync(manifestPath)
+    ? JSON.parse(fs.readFileSync(manifestPath, 'utf-8'))
+    : {};
+  const existingTemplated = existingManifest.templated || {};
+  const existingCicd = existingManifest.cicd || {};
+
+  // Helper: get package name from project.json → version.json → pyproject.toml
+  const getPackageNameFromFiles = (pkgDir) => {
+    const projectJsonPath = path.join(pkgDir, 'project.json');
+    if (fs.existsSync(projectJsonPath)) {
+      try { const d = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8')); if (d.name) return d.name; } catch(e) {}
+    }
+    const versionJsonPath = path.join(pkgDir, 'version.json');
+    if (fs.existsSync(versionJsonPath)) {
+      try { const d = JSON.parse(fs.readFileSync(versionJsonPath, 'utf-8')); if (d.name) return d.name; } catch(e) {}
+    }
+    const pyprojectPath = path.join(pkgDir, 'pyproject.toml');
+    if (fs.existsSync(pyprojectPath)) {
+      try {
+        const content = fs.readFileSync(pyprojectPath, 'utf-8');
+        const match = content.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+        if (match) return match[1];
+      } catch(e) {}
+    }
+    return null;
+  };
+
+  // Helper: derive best-fit template from cicd output type using underscore-prefixed template files
+  const deriveTemplate = (pkgName) => {
+    let lookfor = "node";
+    if (cicd[pkgName]["output"] == "pypi") lookfor = "python";
+    if (cicd[pkgName]["output"] == "nuget") lookfor = "dotnet";
+    if (cicd[pkgName]["output"] == "docker") lookfor = "docker";
+    for (const file of build) {
+      if (file.includes(lookfor)) return file;
+    }
+    return build[0] || null;
+  };
+
+  // Helper: find existing template assignment for a package name in existing manifest
+  const getExistingTemplate = (pkgName) => {
+    for (const pf of Object.keys(existingTemplated)) {
+      for (const ph of Object.keys(existingTemplated[pf] || {})) {
+        const val = (existingTemplated[pf][ph] || {})[pkgName];
+        if (val !== undefined) return { pipelineFile: pf, placeholder: ph, tpl: val };
+      }
+    }
+    return null;
+  };
+
+  // Start from existing templated config so updates are additive-only.
+  const templated = JSON.parse(JSON.stringify(existingTemplated));
+
+  // Ensure discovered pipeline file and placeholder keys exist without removing prior keys.
+  if (pipelineFiles.length === 0) pipelineFiles = ["build.yml"];
+  for (const pipelineFile of pipelineFiles) {
+    if (!templated[pipelineFile]) templated[pipelineFile] = {};
+    for (const placeholder of Object.keys(placeholderMap[pipelineFile] || {})) {
+      if (!templated[pipelineFile][placeholder]) templated[pipelineFile][placeholder] = {};
+    }
+    if (Object.keys(templated[pipelineFile]).length === 0) {
+      templated[pipelineFile]["PACKAGES"] = {};
+    }
+  }
+
+  Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
+    if (!cicd[pkgName]) return;
+
+    const pkgDir = path.dirname(pkgPath);
+    const folderName = path.basename(path.dirname(path.dirname(pkgPath)));
+
+    // Prefer package name from project.json/version.json/pyproject.toml
+    const preferredName = getPackageNameFromFiles(pkgDir) || pkgName;
+
+    // Find the pipeline file and placeholder for this package's folder
+    const entry = folderToEntry[folderName];
+    const pipelineFile = (entry && entry.pipelineFile) || pipelineFiles[0] || "build.yml";
+    let placeholder, template;
+
+    if (entry) {
+      placeholder = entry.placeholder;
+      template = entry.template;
+    } else {
+      // No folder mapping: pick best placeholder by output type
+      const lookfor = cicd[pkgName]["output"] == "pypi" ? "python" :
+                      cicd[pkgName]["output"] == "nuget" ? "dotnet" :
+                      cicd[pkgName]["output"] == "docker" ? "docker" : "node";
+      let bestPh = null, bestTpl = deriveTemplate(pkgName);
+      for (const [ph, info] of Object.entries(placeholderMap[pipelineFile] || {})) {
+        if (info.template && info.template.toLowerCase().includes(lookfor)) {
+          bestPh = ph;
+          bestTpl = info.template;
+          break;
+        }
+      }
+      placeholder = bestPh || "PACKAGES";
+      template = bestTpl;
+    }
+
+    if (!templated[pipelineFile]) templated[pipelineFile] = {};
+    if (!templated[pipelineFile][placeholder]) templated[pipelineFile][placeholder] = {};
+
+    // Additive-only behavior: keep any existing assignment and only add missing entries.
+    const existing = getExistingTemplate(preferredName) || getExistingTemplate(pkgName);
+    if (!existing) {
+      templated[pipelineFile][placeholder][preferredName] = template || deriveTemplate(pkgName);
+    }
+  });
+
+  // Merge in any pre-existing cicd fields (hash, folderName, packageFolder set by release:finalize)
+  Object.keys(existingCicd).forEach(pkgName => {
+    if (cicd[pkgName]) {
+      // Preserve fields from the existing entry that we don't regenerate
+      if (existingCicd[pkgName].hash) cicd[pkgName].hash = existingCicd[pkgName].hash;
+      if (existingCicd[pkgName].version) cicd[pkgName].version = existingCicd[pkgName].version;
+    } else {
+      // If package was in cicd before but not now, preserve entire entry
+      cicd[pkgName] = existingCicd[pkgName];
+    }
+  });
+
+  // Final output structure
+  const output = {
+    versions,
+    dependencies,
+    dependents,
+    pipelines,
+    templated,
+    cicd
+  };
+
+  const outputJson = JSON.stringify(output, null, 2)
+  if(options.save) fs.writeFileSync(`./${configDir}/manifest.json`, outputJson, 'utf-8');
+  return outputJson;
+};

package/src/options.mjs

@@ -0,0 +1,33 @@
+export const getDefaultOptions = () => ({
+  debug: false,
+  platform: null,
+  hashExcludeFolders: ['node_modules', 'coverage', 'dist'],
+  hashExcludeFiles: ['.npmrc', 'CHANGELOG.md', 'README.md']
+});
+
+export const parseCliArgs = (argv = process.argv) => {
+  const options = getDefaultOptions();
+  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') {
+      const name = argv[i].substring(2);
+      options[name] = argv[i + 1].split(',');
+      i++;
+    } else if (argv[i].substring(0, 2) === '--') {
+      const name = argv[i].substring(2);
+      if (options[name] !== undefined) {
+        options[name] = argv[i + 1];
+        i++;
+      } else {
+        throw new Error(`Expected a known option, got ${argv[i]}`);
+      }
+    }
+  }
+  return options;
+};

package/tests/manifest.test.mjs

@@ -0,0 +1,105 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { describe, it, expect } from '@jest/globals';
+import { generateManifest } from '../src/manifest.mjs';
+
+const writeJson = (filePath, obj) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(obj, null, 2), 'utf-8');
+};
+
+describe('generateManifest templated behavior', () => {
+  it('keeps existing templated mappings and adds missing packages only', async () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'manifest-tests-'));
+    const oldCwd = process.cwd();
+
+    try {
+      writeJson(path.join(tmpRoot, 'packages/lib-a/package.json'), {
+        name: 'lib-a',
+        version: '1.0.0',
+        main: 'index.js'
+      });
+
+      writeJson(path.join(tmpRoot, 'packages/lib-b/package.json'), {
+        name: 'lib-b',
+        version: '1.0.0',
+        main: 'index.js'
+      });
+
+      fs.mkdirSync(path.join(tmpRoot, '.cicd/templates'), { recursive: true });
+      fs.writeFileSync(path.join(tmpRoot, '.cicd/templates/build.yml'), 'stages: []\n', 'utf-8');
+      fs.writeFileSync(path.join(tmpRoot, '.cicd/templates/_build_node_package.yml'), '# node build template\n', 'utf-8');
+
+      writeJson(path.join(tmpRoot, '.cicd/manifest.json'), {
+        templated: {
+          'build.yml': {
+            PACKAGES: {
+              'lib-a': 'custom_existing_template.yml'
+            }
+          },
+          'legacy.yml': {
+            PACKAGES: {
+              'legacy-pkg': 'legacy_template.yml'
+            }
+          }
+        }
+      });
+
+      process.chdir(tmpRoot);
+      const output = JSON.parse(await generateManifest({ platform: 'ado' }));
+
+      expect(output.templated['build.yml'].PACKAGES['lib-a']).toBe('custom_existing_template.yml');
+      expect(output.templated['build.yml'].PACKAGES['lib-b']).toBe('_build_node_package.yml');
+
+      expect(output.templated['legacy.yml']).toBeDefined();
+      expect(output.templated['legacy.yml'].PACKAGES['legacy-pkg']).toBe('legacy_template.yml');
+    } finally {
+      process.chdir(oldCwd);
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('ignores unparseable YAML templates and continues', async () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'manifest-tests-'));
+    const oldCwd = process.cwd();
+
+    try {
+      writeJson(path.join(tmpRoot, 'packages/lib-a/package.json'), {
+        name: 'lib-a',
+        version: '1.0.0',
+        main: 'index.js'
+      });
+
+      fs.mkdirSync(path.join(tmpRoot, '.cicd/templates'), { recursive: true });
+      fs.writeFileSync(path.join(tmpRoot, '.cicd/templates/good.yml'), 'stages:\n  build:\n    name: Build\n', 'utf-8');
+      fs.writeFileSync(path.join(tmpRoot, '.cicd/templates/bad.yml'), 'stages:\n  build: [\n', 'utf-8');
+      fs.writeFileSync(path.join(tmpRoot, '.cicd/templates/_build_node_package.yml'), '# node build template\n', 'utf-8');
+
+      writeJson(path.join(tmpRoot, '.cicd/templates/templated.json'), {
+        'good.yml': {
+          PACKAGES: {
+            rootPath: '../packages',
+            template: 'build_node_package.yml'
+          }
+        },
+        'bad.yml': {
+          PACKAGES: {
+            rootPath: '../packages',
+            template: 'build_node_package.yml'
+          }
+        }
+      });
+
+      process.chdir(tmpRoot);
+      const output = JSON.parse(await generateManifest({ platform: 'ado' }));
+
+      expect(output.pipelines['good.yml']).toBeDefined();
+      expect(Array.isArray(output.pipelines['good.yml'])).toBe(true);
+      expect(output.pipelines['bad.yml']).toBeUndefined();
+    } finally {
+      process.chdir(oldCwd);
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+});

package/tests/options.test.mjs

@@ -0,0 +1,40 @@
+import { describe, it, expect } from '@jest/globals';
+import { getDefaultOptions, parseCliArgs } from '../src/options.mjs';
+
+describe('manifest CLI options', () => {
+  it('returns expected defaults', () => {
+    expect(getDefaultOptions()).toEqual({
+      debug: false,
+      platform: null,
+      hashExcludeFolders: ['node_modules', 'coverage', 'dist'],
+      hashExcludeFiles: ['.npmrc', 'CHANGELOG.md', 'README.md']
+    });
+  });
+
+  it('parses boolean and valued flags', () => {
+    const options = parseCliArgs([
+      'node',
+      'index.mjs',
+      '--save',
+      '--debug',
+      '--platform',
+      'github',
+      '--hashExcludeFolders',
+      'node_modules,dist',
+      '--hashExcludeFiles',
+      'README.md,CHANGELOG.md'
+    ]);
+
+    expect(options.save).toBe(true);
+    expect(options.debug).toBe(true);
+    expect(options.platform).toBe('github');
+    expect(options.hashExcludeFolders).toEqual(['node_modules', 'dist']);
+    expect(options.hashExcludeFiles).toEqual(['README.md', 'CHANGELOG.md']);
+  });
+
+  it('throws on unknown option', () => {
+    expect(() => parseCliArgs(['node', 'index.mjs', '--nope'])).toThrow(
+      'Expected a known option, got --nope'
+    );
+  });
+});