enablement-build-template-generate 1.0.19 → 1.3.0

package/README.md

@@ -12,11 +12,13 @@ npx enablement-build-template-generate@latest [flags]
 
 ## How it works
 
-1. **Detect platform** — Checks for `manifest.json` (preferred) or `templated.json` (legacy) in `.cicd/` (ADO) or `.github/` (GitHub). Defaults to `ado` if none are found, or use `--platform` to override.
-2. **Read config** — If `manifest.json` is present, reads the `templated` section (each package maps to its own job template file). If only `templated.json` is present, reads the legacy `{ rootPath, template }` format and globs for packages automatically.
-3. **Expand job templates** — For each package, reads its job snippet template and fills in placeholders. When using `manifest.json`, metadata (`folderName`, `packageFolder`) comes from `manifest.cicd`; when using `templated.json`, package names are read from each folder's manifest file.
-4. **Stitch** — Joins all expanded job snippets and substitutes them into the document template at the named placeholder.
-5. **Write output** — Writes the final file one level above the template directory (`.github/templates/` → `.github/` or `.cicd/templates/` → `.cicd/`), wrapped in `DO NOT EDIT` banners.
+1. **Select platform** — Uses Azure DevOps (`.cicd/`) by default. Pass `--platform github` to use GitHub (`.github/`).
+2. **Read config** — `{configDir}/templates/templated.json` is the source of truth. If `manifest.json` still has a `templated` section (from older tooling), it's read once, merged into `templated.json`, and removed from `manifest.json`. A `templated.json` in the legacy `{ rootPath, template }` shape is converted to the current format (packages discovered by globbing `rootPath`).
+3. **Detect new packages** — Any package not yet assigned a template (scanned via `--children`/auto-detected workspace roots) is classified by type (node/python/dotnet/docker) and assigned a template, reusing the convention of other packages in the same folder or of the same type where possible.
+4. **Persist** — `templated.json` (and `manifest.json`, if it needed migrating) is written back, only when something actually changed.
+5. **Expand job templates** — For each package, reads its job snippet template and fills in placeholders (`folderName`/`packageFolder`/`metadata` come from `templated.json`'s own `cicd` section). Packages are ordered so that, per `manifest.json`'s `dependencies` graph (when present), a package's local dependencies are generated before it, as much as possible.
+6. **Stitch** — Joins all expanded job snippets and substitutes them into the document template at the named placeholder.
+7. **Write output** — Writes the final file one level above the template directory (`.github/templates/` → `.github/` or `.cicd/templates/` → `.cicd/`), wrapped in `DO NOT EDIT` banners.
 
 ---
 
@@ -24,22 +26,22 @@ npx enablement-build-template-generate@latest [flags]
 
 | Flag | Default | Description |
 |---|---|---|
-| `--platform <name>` | auto-detect | Force the platform: `ado` (Azure DevOps) or `github` (GitHub Actions). Auto-detected from `manifest.json` or `templated.json` presence in `.cicd/` or `.github/`. |
-| `--exclude <list>` | — | Comma- or space-separated list of package folder names to skip during generation. |
+| `--platform <name>` | `ado` | Select the platform: `ado` (Azure DevOps) or `github` (GitHub Actions). |
+| `--children <dirs>` | auto-detect | Comma- or space-separated list of top-level directories to scan when detecting new (not-yet-configured) packages. When omitted, directories are read from `pnpm-workspace.yaml` or `package.json` workspaces automatically. |
+| `--exclude <list>` | — | Comma- or space-separated list of names to skip: package folder names during generation, and top-level directories (from `--children` or auto-detection) during new-package scanning. |
 | `--debug` | off | Print verbose output. |
 
 ---
 
 ## Config source
 
-The generator supports two config formats, checked in this order:
+### `templated.json` (current format)
 
-### 1. `manifest.json` (preferred)
-
-Reads the `templated` section of `{configDir}/manifest.json` (produced by `enablement-build-manifest`). Each key is the **output filename**; each value maps a placeholder variable name to a per-package template mapping.
+`{configDir}/templates/templated.json` is the source of truth for template routing. Each key under `templated` is the **output filename**; each value maps a placeholder variable name to a per-package template mapping. `cicd` carries the per-package metadata generation needs.
 
 ```json
 {
+  "version": 2,
   "templated": {
     "build.yml": {
       "PACKAGES": {
@@ -48,30 +50,24 @@ Reads the `templated` section of `{configDir}/manifest.json` (produced by `enabl
         "my-scope/python-lib":  ["build_python_package.yml", "build_scan.yml"]
       }
     }
+  },
+  "cicd": {
+    "my-scope/component-a": { "folderName": "component-a", "packageFolder": "packages" }
   }
 }
 ```
 
 Each package name maps to a **single template filename** or an **array of template filenames** (all expanded in order for that package). Template lookup tries the active platform templates directory first (`.cicd/templates/` or `.github/templates/`) and then falls back to the other platform directory if a file is missing.
 
-Package metadata (`folderName`, `packageFolder`) is read from `manifest.cicd[packageName]` and used to fill template placeholders.
+Package metadata (`folderName`, `packageFolder`, `metadata`) is read from `templated.json`'s own `cicd` map and used to fill template placeholders.
 
-### 2. `templated.json` (legacy fallback)
+A `templated.json` in the legacy `{ rootPath, template }` shape (no top-level `templated`/`version` key) is converted to the current format automatically — packages are discovered by globbing `rootPath` for `package.json`/`version.json`/`pyproject.toml`, and the result is written back.
 
-When `manifest.json` is absent, reads `{configDir}/templates/templated.json`. Each entry provides a `rootPath` to glob for packages and a single `template` applied to all discovered packages. Template lookup still uses active-platform-first, then falls back to the other platform templates folder if needed.
+### `manifest.json` (one-time migration source + dependency graph)
 
-```json
-{
-  "build.yml": {
-    "PACKAGES": {
-      "rootPath": "../../packages",
-      "template": "build_node_component.yml"
-    }
-  }
-}
-```
+If `{configDir}/manifest.json` still has a `templated` section (from older tooling, or `enablement-build-manifest` before it stopped writing one), it's merged into `templated.json` and removed from `manifest.json` — existing assignments in `templated.json` win over stale ones from `manifest.json`.
 
-Package names are read from each folder's `package.json`, `version.json`, or `pyproject.toml`.
+Independently of that migration, when `manifest.json` exists its `dependencies` map (`{ "<package>": ["<local-dep>", ...] }`) is used to order generation: within each placeholder, a package's local dependencies are generated before it, as much as possible (dependencies outside that placeholder's package list, or on a package that also depends back on it, are simply skipped rather than causing an error).
 
 ---
 
@@ -101,6 +97,9 @@ Each job snippet template is expanded once per package. The following placeholde
 | `{full}` | Full npm package name including scope (e.g. `@scope/my-component`) |
 | `{path}` | The package folder root (from `cicd[pkg].packageFolder`, e.g. `packages`) |
 | `{other}` | Expands to a comma-separated list of paths to every **other** package in the same variable — useful for pipeline dependency declarations |
+| `{metadataKey}` | Custom placeholders like `{owner}` or `{tier}` are replaced from `templated.json`'s `cicd[packageName].metadata` |
+
+Custom metadata placeholders aren't supported for a package still being discovered via the legacy `{ rootPath, template }` conversion (they remain unchanged in output) — once converted, `templated.json`'s `cicd` map can carry `metadata` for any package.
 
 ---
 
@@ -108,25 +107,25 @@ Each job snippet template is expanded once per package. The following placeholde
 
 Job template files live in the templates subfolder; document templates and generated output files are one level up.
 
-**Azure DevOps** (when `.cicd/manifest.json` exists):
+**Azure DevOps**:
 ```
 .cicd/
-├── manifest.json          ← source of truth for templated config (preferred)
+├── manifest.json          ← optional: dependency graph for ordering, one-time templated migration source
 ├── build.yml              ← generated output
 └── templates/
     ├── build.yml          ← document template
-    ├── templated.json     ← legacy config (used when manifest.json is absent)
+    ├── templated.json     ← source of truth for templated config
     └── build_node_component.yml  ← job snippet template
 ```
 
-**GitHub Actions** (when `.github/manifest.json` exists):
+**GitHub Actions**:
 ```
 .github/
-├── manifest.json          ← source of truth for templated config (preferred)
+├── manifest.json          ← optional: dependency graph for ordering, one-time templated migration source
 ├── build.yml              ← generated output
 └── templates/
     ├── build.yml          ← document template
-    ├── templated.json     ← legacy config (used when manifest.json is absent)
+    ├── templated.json     ← source of truth for templated config
     └── build_node_component.yml  ← job snippet template
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enablement-build-template-generate",
-  "version": "1.0.19",
+  "version": "1.3.0",
   "description": "Generates build yaml for mono repos",
   "type": "module",
   "module": "./src/index.mjs",
@@ -8,7 +8,8 @@
   "bin": "./src/index.mjs",
   "dependencies": {
     "globby": "^16.2.0",
-    "user": "^0.0.0"
+    "user": "^0.0.0",
+    "enablement-build-manifest": "1.4.0"
   },
   "devDependencies": {
     "jest": "^30.4.2"

package/src/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import * as url from 'url';
 import path from 'path';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
 import { globby } from 'globby';
 
 import {
@@ -15,6 +15,17 @@ import {
   resolveOtherPlaceholders,
   applyVarsToDocTemplate,
   wrapWithBanner,
+  resolveWorkspaceChildren,
+  excludeChildren,
+  buildPackageJsonGlob,
+  detectCicdType,
+  isAdvancedTemplatedFormat,
+  TEMPLATED_JSON_ADVANCED_VERSION,
+  extractGenerationCicd,
+  collectAssignedPackages,
+  listBuildTemplateFiles,
+  chooseAssignmentForNewPackage,
+  topologicalSort,
 } from './lib.mjs';
 
 const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
@@ -32,19 +43,54 @@ function readJobTemplate(templateFile, templatePath, fallbackTemplatePath) {
   throw new Error(`Template file not found: ${templateFile} (looked in ${templatePath}${fallbackTemplatePath ? ' and ' + fallbackTemplatePath : ''})`);
 }
 
+
+// Resolve package folder name for {name}: prefer cicd.folderName, otherwise infer from disk.
+function resolveFolderName(pkgName, info = {}) {
+  if (info.folderName) return info.folderName;
+
+  const packageFolder = info.packageFolder || 'packages';
+  const packageRoot = path.join(process.cwd(), packageFolder);
+  if (!existsSync(packageRoot)) return resolvePackageName(pkgName);
+
+  const dirs = readdirSync(packageRoot, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => entry.name);
+
+  for (const dirName of dirs) {
+    const base = path.join(packageRoot, dirName);
+    const candidates = ['package.json', 'version.json', 'pyproject.toml'];
+
+    for (const candidate of candidates) {
+      const manifestPath = path.join(base, candidate);
+      if (!existsSync(manifestPath)) continue;
+
+      const ext = path.extname(candidate).substring(1).toLowerCase();
+      const content = readFileSync(manifestPath, 'utf8');
+      const parsedName = parseManifestName(content, ext);
+
+      if (parsedName === pkgName) return dirName;
+    }
+  }
+
+  return resolvePackageName(pkgName);
+}
+
 // ---------------------------------------------------------------------------
 // Expand using manifest.json "templated" section (new format)
 // ---------------------------------------------------------------------------
-function expandVarFromManifest(varname, packageMap, cicd, templatePath, fallbackTemplatePath, options) {
+function expandVarFromManifest(varname, packageMap, cicd, templatePath, fallbackTemplatePath, options, dependencies = {}) {
   return new Promise((resolve, reject) => {
     try {
-      const packageNames = Object.keys(packageMap).filter(pkg => {
+      const filteredNames = Object.keys(packageMap).filter(pkg => {
         if (packageMap[pkg] === false) return false;
-        const folderName = (cicd[pkg] || {}).folderName || pkg;
+        const folderName = resolveFolderName(pkg, cicd[pkg] || {});
         return !options.exclude.includes(folderName);
       });
+      // Order so a package's local dependencies are generated before it,
+      // as much as possible (per manifest.json's "dependencies").
+      const packageNames = topologicalSort(filteredNames, dependencies);
 
-      const allFolderNames = packageNames.map(pkg => (cicd[pkg] || {}).folderName || pkg);
+      const allFolderNames = packageNames.map(pkg => resolveFolderName(pkg, cicd[pkg] || {}));
 
       const folderCounts = {};
       packageNames.forEach(pkg => {
@@ -60,7 +106,7 @@ function expandVarFromManifest(varname, packageMap, cicd, templatePath, fallback
           : [packageMap[pkgName]];
 
         const info = cicd[pkgName] || {};
-        const name = info.folderName || pkgName;
+        const name = resolveFolderName(pkgName, info);
         const jobRoot = info.packageFolder || 'packages';
         const safe = makeSafe(name);
         const packageName = resolvePackageName(pkgName);
@@ -81,86 +127,198 @@ function expandVarFromManifest(varname, packageMap, cicd, templatePath, fallback
 }
 
 // ---------------------------------------------------------------------------
-// Expand using templated.json (legacy format: rootPath + template glob)
+// Convert one legacy templated.json entry ({ rootPath, template }) into the
+// advanced format: discover the packages currently under rootPath and assign
+// each of them the entry's template, recording their folder/packageFolder.
 // ---------------------------------------------------------------------------
-function expandVarFromTemplatedJson(varname, jobConfig, templatePath, fallbackTemplatePath, options) {
-  return new Promise((resolve, reject) => {
-    const jobTemplate = readJobTemplate(jobConfig.template, templatePath, fallbackTemplatePath);
-    const cwd = path.join(templatePath, jobConfig.rootPath);
-    const search = buildSearchGlobs(options.exclude);
-
-    globby(search, { cwd }).then((files) => {
-      const folderBest = groupByFolder(files);
-      const allNames = Object.keys(folderBest).sort().filter(n => !options.exclude.includes(n));
-
-      const expandedJobs = allNames.map(name => {
-        const content = readFileSync(path.join(cwd, folderBest[name].filePath), 'utf8');
-        const ext = path.extname(folderBest[name].filePath).substring(1).toLowerCase();
-        const fullName = parseManifestName(content, ext) || name;
-        const safe = makeSafe(name);
-        const packageName = resolvePackageName(fullName);
-        const jobRoot = path.relative(process.cwd(), cwd);
-        return expandJobTemplate(jobTemplate, { name, safe, packageName, fullName, jobRoot, metadata: {} });
-      });
+async function convertLegacyEntry(jobConfig, templatePath, options) {
+  const cwd = path.join(templatePath, jobConfig.rootPath);
+  const search = buildSearchGlobs(options.exclude);
+  const files = await globby(search, { cwd });
+
+  const folderBest = groupByFolder(files);
+  const allNames = Object.keys(folderBest).sort().filter(n => !options.exclude.includes(n));
+  const packageFolder = path.relative(process.cwd(), cwd);
+
+  const pkgMap = {};
+  const cicdEntries = {};
+  allNames.forEach(name => {
+    const content = readFileSync(path.join(cwd, folderBest[name].filePath), 'utf8');
+    const ext = path.extname(folderBest[name].filePath).substring(1).toLowerCase();
+    const fullName = parseManifestName(content, ext) || name;
+    pkgMap[fullName] = jobConfig.template;
+    cicdEntries[fullName] = { folderName: name, packageFolder };
+  });
 
-      const jobs = resolveOtherPlaceholders(expandedJobs.join('\n'), allNames, cwd);
-      resolve({ name: varname, text: jobs });
-    }, reject);
+  return { pkgMap, cicdEntries };
+}
+
+// Convert a whole legacy-format templated.json document into the advanced
+// { templated, cicd } shape.
+async function convertLegacyTemplatedJson(rawConfig, templatePath, options) {
+  const templated = {};
+  const cicd = {};
+
+  for (const pipelineFile of Object.keys(rawConfig)) {
+    templated[pipelineFile] = {};
+    for (const varname of Object.keys(rawConfig[pipelineFile])) {
+      const { pkgMap, cicdEntries } = await convertLegacyEntry(rawConfig[pipelineFile][varname], templatePath, options);
+      templated[pipelineFile][varname] = pkgMap;
+      Object.assign(cicd, cicdEntries);
+    }
+  }
+
+  return { templated, cicd };
+}
+
+// ---------------------------------------------------------------------------
+// Discover packages not yet assigned to any template and add them, using
+// detected package type + the existing convention (same packageFolder, else
+// same output type, else the default "PACKAGES" placeholder). Mutates
+// `templated`/`cicd` in place; returns true if anything was added.
+// ---------------------------------------------------------------------------
+async function detectAndAssignNewPackages(templated, cicd, options, templatePath) {
+  const assigned = collectAssignedPackages(templated);
+  const buildTemplateFiles = listBuildTemplateFiles(templatePath);
+
+  const pkgPaths = await globby(buildPackageJsonGlob(options.children), {
+    cwd: process.cwd(),
+    ignore: ['**/node_modules/**', '**/tests/**'],
+    absolute: true,
+  });
+
+  let added = false;
+
+  pkgPaths.forEach(pkgPath => {
+    let pkg;
+    try { pkg = JSON.parse(readFileSync(pkgPath, 'utf8')); } catch { return; }
+    if (!pkg.name || !pkg.version || assigned.has(pkg.name)) return;
+
+    const folderName = path.basename(path.dirname(pkgPath));
+    if (options.exclude.includes(folderName)) return;
+
+    const packageFolder = path.basename(path.dirname(path.dirname(pkgPath)));
+    const detected = detectCicdType(pkg.name, pkg, pkgPath);
+    const { pipelineFile, placeholder, template } = chooseAssignmentForNewPackage({
+      packageFolder,
+      output: detected ? detected.output : undefined,
+      templated,
+      cicd,
+      buildTemplateFiles,
+    });
+
+    if (!template) return;
+
+    templated[pipelineFile] = templated[pipelineFile] || {};
+    templated[pipelineFile][placeholder] = templated[pipelineFile][placeholder] || {};
+    templated[pipelineFile][placeholder][pkg.name] = template;
+    cicd[pkg.name] = { ...(cicd[pkg.name] || {}), folderName, packageFolder };
+    assigned.add(pkg.name);
+    added = true;
   });
+
+  return added;
 }
 
 // ---------------------------------------------------------------------------
 // main
 // ---------------------------------------------------------------------------
 async function main(options) {
+  // Detect workspace package roots (pnpm-workspace.yaml or package.json
+  // workspaces), same as monorepo-version and manifest. Used below to scope
+  // discovery of new (not-yet-configured) packages.
+  if (!options.children) {
+    const detected = resolveWorkspaceChildren(process.cwd());
+    if (detected) {
+      if (options.debug) console.log(`Auto-detected workspace children: ${detected}`);
+      options.children = detected;
+    }
+  }
+
+  // --exclude drops specific root directories from whichever children list is
+  // in effect, auto-detected or explicit. The same list is also used below to
+  // filter individual packages by folder name during generation.
+  if (options.exclude.length > 0) {
+    options.children = excludeChildren(options.children, options.exclude) || options.children;
+  }
+
   const configDir = options.platform === 'github' ? '.github' : '.cicd';
   const altConfigDir = options.platform === 'github' ? '.cicd' : '.github';
   const templatePath = path.join(process.cwd(), `${configDir}/templates`);
   const fallbackTemplatePath = path.join(process.cwd(), `${altConfigDir}/templates`);
 
-  // Try manifest.json first, then fall back to templated.json
   const manifestPath = path.join(process.cwd(), `${configDir}/manifest.json`);
   const templatedJsonPath = path.join(process.cwd(), `${configDir}/templates/templated.json`);
 
-  const useManifest = existsSync(manifestPath);
-  const useTemplatedJson = !useManifest && existsSync(templatedJsonPath);
-
-  if (!useManifest && !useTemplatedJson) {
-    throw `enablement-build-template-generate: could not find manifest.json at ${configDir}/manifest.json or templated.json at ${configDir}/templates/templated.json`;
+  // ── Load config: manifest.json's "templated" section (if still present, to
+  // be migrated out), else templated.json (new or legacy format). Whatever we
+  // load is normalized into { templated, cicd } once, up front, so generation
+  // below always runs the same (advanced-format) code path.
+  let templated;
+  let cicd;
+  let manifestToPersist = null; // set when manifest.json needs its "templated" section stripped
+  let templatedJsonDirty = false; // set when templated.json needs (re)writing
+  let dependencies = {}; // manifest.json's local dependency graph, for ordering generation
+
+  if (existsSync(manifestPath)) {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8') || '{}');
+    dependencies = manifest.dependencies || {};
+    if (isAdvancedTemplatedFormat(manifest)) {
+      templated = manifest.templated;
+      cicd = extractGenerationCicd(manifest.cicd || {});
+      delete manifest.templated;
+      manifestToPersist = manifest;
+      templatedJsonDirty = true;
+    }
   }
 
-  let config;
-  let cicd = {};
+  if (!templated) {
+    if (!existsSync(templatedJsonPath)) {
+      throw `enablement-build-template-generate: could not find manifest.json "templated" section at ${configDir}/manifest.json or templated.json at ${configDir}/templates/templated.json`;
+    }
 
-  if (useManifest) {
-    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-    if (!manifest.templated) {
-      throw `enablement-build-template-generate: manifest.json has no "templated" section`;
+    const raw = JSON.parse(readFileSync(templatedJsonPath, 'utf8') || '{}');
+    if (isAdvancedTemplatedFormat(raw)) {
+      templated = raw.templated;
+      cicd = raw.cicd || {};
+      if (typeof raw.version !== 'number') {
+        // Advanced format but predates the version field: write it back once,
+        // purely to backfill it, even if nothing else changed.
+        templatedJsonDirty = true;
+      }
+    } else {
+      const converted = await convertLegacyTemplatedJson(raw, templatePath, options);
+      templated = converted.templated;
+      cicd = converted.cicd;
+      templatedJsonDirty = true;
     }
-    config = manifest.templated;
-    cicd = manifest.cicd || {};
-  } else {
-    config = JSON.parse(readFileSync(templatedJsonPath, 'utf8'));
   }
 
+  // ── Discover packages not yet assigned to any template and add them.
+  if (await detectAndAssignNewPackages(templated, cicd, options, templatePath)) {
+    templatedJsonDirty = true;
+  }
+
+  // ── Persist. At most one write to each file, only when something changed.
+  if (manifestToPersist) {
+    writeFileSync(manifestPath, JSON.stringify(manifestToPersist, null, 2), 'utf8');
+  }
+  if (templatedJsonDirty) {
+    writeFileSync(templatedJsonPath, JSON.stringify({ version: TEMPLATED_JSON_ADVANCED_VERSION, templated, cicd }, null, 2), 'utf8');
+  }
+
+  // ── Generate.
   const plist = [];
 
-  Object.keys(config).forEach((templateFilename) => {
+  Object.keys(templated).forEach((templateFilename) => {
     plist.push(new Promise((primaryResolve, reject) => {
       try {
         const docTemplate = readFileSync(path.join(templatePath, templateFilename), 'utf8');
         const jlist = [];
 
-        Object.keys(config[templateFilename]).forEach((varname) => {
-          const varConfig = config[templateFilename][varname];
-
-          if (useManifest) {
-            // New format: varConfig is { pkgName: "template.yml" | [...] }
-            jlist.push(expandVarFromManifest(varname, varConfig, cicd, templatePath, fallbackTemplatePath, options));
-          } else {
-            // Legacy format: varConfig is { rootPath, template, exclude? }
-            jlist.push(expandVarFromTemplatedJson(varname, varConfig, templatePath, fallbackTemplatePath, options));
-          }
+        Object.keys(templated[templateFilename]).forEach((varname) => {
+          const varConfig = templated[templateFilename][varname];
+          jlist.push(expandVarFromManifest(varname, varConfig, cicd, templatePath, fallbackTemplatePath, options, dependencies));
         });
 
         Promise.all(jlist).then((results) => {
@@ -188,9 +346,10 @@ async function main(options) {
 // CLI
 // ---------------------------------------------------------------------------
 let options = {
-  platform: null,
+  platform: 'ado',
   exclude: [],
   debug: false,
+  children: null,
 };
 
 let argv = process.argv;
@@ -211,20 +370,6 @@ for (let i = 2; i < argv.length; i++) {
   }
 }
 
-if (!options.platform) {
-  const hasGithubManifest  = existsSync(path.join(process.cwd(), '.github/manifest.json'));
-  const hasAdoManifest     = existsSync(path.join(process.cwd(), '.cicd/manifest.json'));
-  const hasGithubTemplated = existsSync(path.join(process.cwd(), '.github/templates/templated.json'));
-  const hasAdoTemplated    = existsSync(path.join(process.cwd(), '.cicd/templates/templated.json'));
-
-  if (hasGithubManifest || hasGithubTemplated) {
-    options.platform = 'github';
-  } else if (hasAdoManifest || hasAdoTemplated) {
-    options.platform = 'ado';
-  } else {
-    options.platform = 'ado';
-  }
-}
 
 (async () => {
   try {