monecromanci 0.0.0

package/dist/cli.js

@@ -0,0 +1,2466 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_node_fs5 = require("fs");
+var import_node_path9 = require("path");
+var import_commander = require("commander");
+
+// src/engine/config.ts
+var import_node_path2 = require("path");
+
+// src/engine/constants.ts
+var TEMPLATE_VERSION = "0.2.0";
+var STAMP_FILE = ".monecromanci.json";
+var DEFAULT_NODE_VERSION = "24";
+var DEFAULT_BASE = "main";
+var TAGS = {
+  functionApp: "type:function-app",
+  nodeApp: "type:node-app",
+  reactApp: "type:react-app",
+  vueApp: "type:vue-app",
+  svelteApp: "type:svelte-app",
+  nextjsApp: "type:nextjs-app",
+  publishableLib: "type:publishable-lib",
+  internalLib: "type:internal-lib",
+  ignore: "ci:ignore"
+};
+
+// src/engine/fsx.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_fs2 = require("fs");
+function ensureDirectory(directory) {
+  if (!(0, import_node_fs.existsSync)(directory)) {
+    (0, import_node_fs.mkdirSync)(directory, { recursive: true });
+  }
+}
+function writeFileEnsured(filePath, content) {
+  ensureDirectory((0, import_node_path.dirname)(filePath));
+  (0, import_node_fs.writeFileSync)(filePath, content, "utf8");
+}
+function readJsonSafe(filePath, fallback) {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function readTextSafe(filePath) {
+  try {
+    return (0, import_node_fs.readFileSync)(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function toJson(value) {
+  return `${JSON.stringify(value, void 0, 2)}
+`;
+}
+
+// src/engine/config.ts
+function stampPath(repoRoot) {
+  return (0, import_node_path2.join)(repoRoot, STAMP_FILE);
+}
+function isManagedRepo(repoRoot) {
+  return (0, import_node_fs2.existsSync)(stampPath(repoRoot));
+}
+function migrateConfig(raw) {
+  const registry = raw.registry ?? (raw.azure ? { kind: "azure-artifacts", ...raw.azure } : { kind: "npm" });
+  return { ...raw, ci: raw.ci ?? "azure", registry };
+}
+function loadConfig(repoRoot) {
+  if (!isManagedRepo(repoRoot)) {
+    return void 0;
+  }
+  const raw = readJsonSafe(stampPath(repoRoot), void 0);
+  return raw ? migrateConfig(raw) : void 0;
+}
+function saveConfig(repoRoot, config) {
+  writeFileEnsured(stampPath(repoRoot), toJson(config));
+}
+function configFromVars(vars) {
+  return {
+    templateVersion: TEMPLATE_VERSION,
+    workspaceName: vars.workspaceName,
+    displayName: vars.displayName,
+    scope: vars.scope,
+    defaultBase: vars.defaultBase,
+    nodeVersion: vars.nodeVersion,
+    ci: vars.ci,
+    registry: vars.registry
+  };
+}
+
+// src/util/logger.ts
+var logger = {
+  info(message) {
+    console.log(message);
+  },
+  step(message) {
+    console.log(`\u2192 ${message}`);
+  },
+  success(message) {
+    console.log(`\u2713 ${message}`);
+  },
+  warn(message) {
+    console.warn(`! ${message}`);
+  },
+  error(message) {
+    console.error(`\u2717 ${message}`);
+  }
+};
+
+// src/util/prompts.ts
+var import_prompts = require("@inquirer/prompts");
+var import_prompts2 = require("@inquirer/prompts");
+async function promptText(message, fallback) {
+  const value = await (0, import_prompts.input)({
+    message,
+    default: fallback,
+    validate: (value2) => value2.trim().length > 0 || "A value is required"
+  });
+  return value.trim();
+}
+
+// src/util/strings.ts
+function toSlug(input3) {
+  return input3.trim().replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").replaceAll(/[^a-zA-Z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "").toLowerCase();
+}
+
+// src/engine/apply.ts
+var import_node_path3 = require("path");
+function applyFiles(repoRoot, files) {
+  const result = { created: [], overwritten: [], skipped: [] };
+  for (const file of files) {
+    const absolute = (0, import_node_path3.join)(repoRoot, file.path);
+    const exists = (0, import_node_fs2.existsSync)(absolute);
+    if (file.ownership === "scaffold" && exists) {
+      result.skipped.push(file.path);
+      continue;
+    }
+    writeFileEnsured(absolute, file.content);
+    if (exists) {
+      result.overwritten.push(file.path);
+    } else {
+      result.created.push(file.path);
+    }
+  }
+  return result;
+}
+function reportApply(result) {
+  for (const path of result.created) {
+    logger.success(`created ${path}`);
+  }
+  for (const path of result.overwritten) {
+    logger.step(`updated ${path}`);
+  }
+  for (const path of result.skipped) {
+    logger.info(`  kept    ${path} (already exists)`);
+  }
+}
+
+// src/engine/rootPackage.ts
+var import_node_path4 = require("path");
+function addRootDependencies(repoRoot, dependencies, section = "dependencies") {
+  const manifestPath = (0, import_node_path4.join)(repoRoot, "package.json");
+  const manifest = readJsonSafe(manifestPath, {});
+  const existing = manifest[section] ?? {};
+  const added = [];
+  for (const [name, version] of Object.entries(dependencies)) {
+    if (Object.hasOwn(existing, name)) {
+      continue;
+    }
+    existing[name] = version;
+    added.push(name);
+  }
+  manifest[section] = Object.fromEntries(
+    Object.entries(existing).toSorted(([left], [right]) => left.localeCompare(right))
+  );
+  writeFileEnsured(manifestPath, toJson(manifest));
+  return added;
+}
+
+// src/templates/frontendApp.ts
+function appPackageJson(vars) {
+  return toJson({
+    name: vars.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      "build:dev": "vite build --mode dev --outDir dist-dev",
+      "build:uat": "vite build --mode uat --outDir dist-uat",
+      "build:prod": "vite build --mode prod --outDir dist-prod",
+      "build:all": "npm run build:dev && npm run build:uat && npm run build:prod",
+      build: "npm run build:dev",
+      preview: "vite preview",
+      lint: "eslint . -c ../../eslint.config.mjs",
+      test: "jest --collectCoverage"
+    }
+  });
+}
+function appProjectJson(vars, framework) {
+  const run = (target) => ({
+    executor: "nx:run-commands",
+    options: { command: `npm run ${target} -w ${vars.packageName}` }
+  });
+  return toJson({
+    name: vars.name,
+    $schema: "../../node_modules/nx/schemas/project-schema.json",
+    sourceRoot: `apps/${vars.name}/src`,
+    projectType: "application",
+    tags: [framework.tag],
+    targets: {
+      build: {
+        executor: "nx:run-commands",
+        outputs: ["{projectRoot}/dist-dev", "{projectRoot}/dist-uat", "{projectRoot}/dist-prod"],
+        options: { command: `npm run build -w ${vars.packageName}` }
+      },
+      serve: run("dev"),
+      test: run("test"),
+      lint: run("lint")
+    }
+  });
+}
+function appTsconfig() {
+  return toJson({
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      target: "es2022",
+      lib: ["es2022", "DOM", "DOM.Iterable"],
+      module: "esnext",
+      moduleResolution: "bundler",
+      types: ["vite/client", "node"],
+      noEmit: true,
+      sourceMap: true,
+      allowSyntheticDefaultImports: true,
+      esModuleInterop: true
+    },
+    include: ["src", "vite.config.ts"]
+  });
+}
+function appTypedoc() {
+  return toJson({
+    extends: ["../../typedoc.json"],
+    entryPoints: ["./src"],
+    out: "doc",
+    exclude: ["./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+function viteConfig(framework) {
+  return `${framework.vitePluginImport}
+import { defineConfig } from 'vite'
+
+export default defineConfig({ plugins: [${framework.vitePluginCall}], server: { port: 5173 }, build: { sourcemap: true } })
+`;
+}
+function indexHtml(vars, framework) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${vars.name}</title>
+  </head>
+  <body>
+    <div id="${framework.mountId}"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`;
+}
+var greetingTs = `/**
+ * Returns the greeting rendered by the app.
+ *
+ * @remarks Shared TS logic \u2014 unit-tested directly so no SFC test transform is needed.
+ * @param name - The name to greet.
+ * @returns The greeting text.
+ * @throws Never - performs no I/O.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export function greet (name: string): string {
+  return 'Hello from ' + name + '!'
+}
+`;
+var greetingTestTs = `import { greet } from './greeting'
+
+describe('greet', () => {
+  it('greets the given name', () => {
+    expect(greet('world')).toBe('Hello from world!')
+  })
+})
+`;
+function envFile(environment) {
+  return `VITE_ENVIRONMENT=${environment}
+VITE_API_URL=https://${environment}.example.com
+`;
+}
+var VUE = {
+  tag: TAGS.vueApp,
+  mountId: "app",
+  vitePluginImport: "import vue from '@vitejs/plugin-vue'",
+  vitePluginCall: "vue()",
+  componentPath: "src/App.vue",
+  componentContent: `<script setup lang="ts">
+import { greet } from './greeting'
+
+const message = greet('Vue')
+</script>
+
+<template>
+  <main>
+    <h1>{{ message }}</h1>
+  </main>
+</template>
+`,
+  mainContent: `import { createApp } from 'vue'
+import App from './App.vue'
+
+createApp(App).mount('#app')
+`,
+  envContent: `/// <reference types="vite/client" />
+
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent
+  export default component
+}
+`
+};
+var SVELTE = {
+  tag: TAGS.svelteApp,
+  mountId: "app",
+  vitePluginImport: "import { svelte } from '@sveltejs/vite-plugin-svelte'",
+  vitePluginCall: "svelte()",
+  componentPath: "src/App.svelte",
+  componentContent: `<script lang="ts">
+  import { greet } from './greeting'
+
+  const message = greet('Svelte')
+</script>
+
+<main>
+  <h1>{ message }</h1>
+</main>
+`,
+  mainContent: `import { mount } from 'svelte'
+import App from './App.svelte'
+
+mount(App, { target: document.querySelector('#app')! })
+`,
+  envContent: `/// <reference types="vite/client" />
+
+declare module '*.svelte' {
+  import type { Component } from 'svelte'
+
+  const component: Component
+  export default component
+}
+`
+};
+function frontendAppFiles(vars, framework) {
+  const root = `apps/${vars.name}`;
+  const file = (path, content, ownership) => ({ path: `${root}/${path}`, content, ownership });
+  return [
+    file("package.json", appPackageJson(vars), "scaffold"),
+    file("project.json", appProjectJson(vars, framework), "tool-owned"),
+    file("tsconfig.json", appTsconfig(), "tool-owned"),
+    file("vite.config.ts", viteConfig(framework), "scaffold"),
+    file("index.html", indexHtml(vars, framework), "scaffold"),
+    file("jest.config.mjs", `import { createConfig } from '../../jest.preset.mjs'
+
+export default createConfig('${vars.name}')
+`, "scaffold"),
+    file("typedoc.json", appTypedoc(), "tool-owned"),
+    file(".env.dev", envFile("dev"), "scaffold"),
+    file(".env.uat", envFile("uat"), "scaffold"),
+    file(".env.prod", envFile("prod"), "scaffold"),
+    file("src/vite-env.d.ts", framework.envContent, "scaffold"),
+    file("src/main.ts", framework.mainContent, "scaffold"),
+    file(framework.componentPath, framework.componentContent, "scaffold"),
+    file("src/greeting.ts", greetingTs, "scaffold"),
+    file("src/greeting.test.ts", greetingTestTs, "scaffold")
+  ];
+}
+function vueAppFiles(vars) {
+  return frontendAppFiles(vars, VUE);
+}
+function svelteAppFiles(vars) {
+  return frontendAppFiles(vars, SVELTE);
+}
+
+// src/engine/assets.ts
+var import_node_fs3 = require("fs");
+var import_node_path5 = require("path");
+var assetsRoot = /* @__PURE__ */ (() => {
+  let cachedRoot;
+  return () => {
+    if (cachedRoot) {
+      return cachedRoot;
+    }
+    let directory = __dirname;
+    for (let level = 0; level < 8; level++) {
+      const candidate = (0, import_node_path5.join)(directory, "assets");
+      if ((0, import_node_fs3.existsSync)(candidate)) {
+        cachedRoot = candidate;
+        return candidate;
+      }
+      const parent = (0, import_node_path5.dirname)(directory);
+      if (parent === directory) {
+        break;
+      }
+      directory = parent;
+    }
+    throw new Error("MoNecromanCI assets directory not found");
+  };
+})();
+function readAsset(relativePath) {
+  return (0, import_node_fs3.readFileSync)((0, import_node_path5.join)(assetsRoot(), relativePath), "utf8");
+}
+function listAssetFiles(relativeDirectory) {
+  const base = (0, import_node_path5.join)(assetsRoot(), relativeDirectory);
+  const files = [];
+  const walk = (directory) => {
+    const entries = (0, import_node_fs3.readdirSync)(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = (0, import_node_path5.join)(directory, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else {
+        files.push((0, import_node_path5.relative)(base, full).split(import_node_path5.sep).join("/"));
+      }
+    }
+  };
+  walk(base);
+  return files;
+}
+
+// src/templates/functionApp.ts
+function appPackageJson2(vars) {
+  return toJson({
+    name: vars.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "commonjs",
+    main: "dist/index.js",
+    dependencies: {},
+    scripts: {
+      build: "tsc -p tsconfig.app.json",
+      watch: "tsc -p tsconfig.app.json -w",
+      start: "func start",
+      "clean:config": "node ../../tools/clean-config.mjs",
+      lint: "eslint . -c ../../eslint.config.mjs",
+      test: "jest --collectCoverage",
+      doc: "typedoc --tsconfig tsconfig.app.json"
+    }
+  });
+}
+function appProjectJson2(vars) {
+  const run = (target) => ({
+    executor: "nx:run-commands",
+    options: { command: `npm run ${target} -w ${vars.packageName}` }
+  });
+  return toJson({
+    name: vars.name,
+    $schema: "../../node_modules/nx/schemas/project-schema.json",
+    sourceRoot: `apps/${vars.name}/src`,
+    projectType: "application",
+    tags: [TAGS.functionApp],
+    targets: {
+      build: { executor: "nx:run-commands", outputs: ["{projectRoot}/dist"], options: { command: `npm run build -w ${vars.packageName}` } },
+      serve: run("start"),
+      test: run("test"),
+      lint: run("lint"),
+      doc: run("doc")
+    }
+  });
+}
+function appTsconfig2() {
+  return toJson({
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      baseUrl: ".",
+      rootDir: ".",
+      outDir: "./dist",
+      module: "commonjs",
+      moduleResolution: "node",
+      target: "es2022",
+      sourceMap: true,
+      declaration: false,
+      declarationMap: false,
+      esModuleInterop: true
+    },
+    exclude: ["./coverage/**", "./dist/**", "./doc/**", "./node_modules/**"]
+  });
+}
+function appTsconfigApp() {
+  return toJson({
+    extends: "./tsconfig.json",
+    compilerOptions: {
+      rootDir: "./src",
+      noEmit: false,
+      sourceMap: true,
+      removeComments: false
+    },
+    exclude: ["./coverage/**", "./dist/**", "./doc/**", "./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+function appTypedoc2() {
+  return toJson({
+    extends: ["../../typedoc.json"],
+    entryPoints: ["./src"],
+    out: "doc",
+    exclude: ["./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+function hostJson() {
+  return toJson({
+    version: "2.0",
+    logging: {
+      applicationInsights: {
+        samplingSettings: { isEnabled: true, excludedTypes: "Request" }
+      }
+    },
+    extensionBundle: {
+      id: "Microsoft.Azure.Functions.ExtensionBundle",
+      version: "[4.*, 5.0.0)"
+    }
+  });
+}
+function localSettingsJson() {
+  return toJson({
+    IsEncrypted: false,
+    Values: {
+      FUNCTIONS_WORKER_RUNTIME: "node",
+      AzureWebJobsStorage: "",
+      languageWorkers__node__arguments: "--inspect=9229"
+    }
+  });
+}
+function configurationFile(environment) {
+  return toJson([
+    { name: "FUNCTIONS_WORKER_RUNTIME", value: "node", slotSetting: false },
+    { name: "WEBSITE_NODE_DEFAULT_VERSION", value: "~24", slotSetting: false },
+    { name: "ENVIRONMENT", value: environment, slotSetting: false }
+  ]);
+}
+var greetingTs2 = `/**
+ * Builds the greeting returned by the sample HTTP function.
+ *
+ * @remarks Pure string helper \u2014 replace with your own logic.
+ * @param name - The name to greet.
+ * @returns The greeting text.
+ * @throws Never - performs no I/O.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export function buildGreeting (name: string): string {
+  return 'Hello, ' + name + '!'
+}
+`;
+var greetingTestTs2 = `import { buildGreeting } from './greeting'
+
+describe('buildGreeting', () => {
+  it('greets a name', () => {
+    expect(buildGreeting('world')).toBe('Hello, world!')
+  })
+})
+`;
+var helloTs = `import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions'
+import { buildGreeting } from '../greeting'
+
+/**
+ * Sample HTTP-triggered function.
+ *
+ * @remarks Registered with the Functions host via the app.http call below.
+ * @param request - The incoming HTTP request.
+ * @param context - The Azure Functions invocation context.
+ * @returns The HTTP response payload.
+ * @throws Never - failures are surfaced by the Functions host.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export async function hello (request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+  context.log('HTTP function processed a request for ' + request.url)
+  const name = request.query.get('name') ?? 'world'
+
+  return { body: buildGreeting(name) }
+}
+
+// app.http performs the Azure Functions v4 registration at import time.
+// eslint-disable-next-line unicorn/no-top-level-side-effects
+app.http('hello', { methods: ['GET'], authLevel: 'anonymous', handler: hello })
+`;
+var indexTs = `import './functions/hello'
+`;
+function functionAppFiles(vars) {
+  const root = `apps/${vars.name}`;
+  const file = (path, content, ownership) => ({ path: `${root}/${path}`, content, ownership });
+  return [
+    file("package.json", appPackageJson2(vars), "scaffold"),
+    file("project.json", appProjectJson2(vars), "tool-owned"),
+    file("tsconfig.json", appTsconfig2(), "tool-owned"),
+    file("tsconfig.app.json", appTsconfigApp(), "tool-owned"),
+    file("host.json", hostJson(), "scaffold"),
+    file("local.settings.json", localSettingsJson(), "scaffold"),
+    file("jest.config.mjs", `import { createConfig } from '../../jest.preset.mjs'
+
+export default createConfig('${vars.name}')
+`, "scaffold"),
+    file("typedoc.json", appTypedoc2(), "tool-owned"),
+    file(".configurations/dev.json", configurationFile("dev"), "scaffold"),
+    file(".configurations/uat.json", configurationFile("uat"), "scaffold"),
+    file(".configurations/prod.json", configurationFile("prod"), "scaffold"),
+    file("src/index.ts", indexTs, "scaffold"),
+    file("src/greeting.ts", greetingTs2, "scaffold"),
+    file("src/greeting.test.ts", greetingTestTs2, "scaffold"),
+    file("src/functions/hello.ts", helloTs, "scaffold"),
+    { path: "tools/clean-config.mjs", content: readAsset("scripts/clean-config.mjs"), ownership: "tool-owned" }
+  ];
+}
+
+// src/templates/internalLib.ts
+function libPackageJson(vars) {
+  return toJson({
+    name: vars.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "commonjs",
+    // Point at source so consumers resolve TS directly: enables step-into-source
+    // debugging and editor "find references" across internal libraries.
+    main: "./src/index.ts",
+    types: "./src/index.ts",
+    dependencies: {},
+    scripts: {
+      build: "tsc -p ./tsconfig.lib.json",
+      test: "jest --collectCoverage",
+      lint: "eslint . -c ../../eslint.config.mjs",
+      doc: "typedoc --tsconfig tsconfig.lib.json"
+    }
+  });
+}
+function libProjectJson(vars) {
+  const run = (target) => ({
+    executor: "nx:run-commands",
+    options: { command: `npm run ${target} -w ${vars.packageName}` }
+  });
+  return toJson({
+    name: vars.name,
+    $schema: "../../node_modules/nx/schemas/project-schema.json",
+    sourceRoot: `libs/${vars.name}/src`,
+    projectType: "library",
+    tags: [TAGS.internalLib],
+    targets: {
+      build: { executor: "nx:run-commands", outputs: ["{projectRoot}/dist"], options: { command: `npm run build -w ${vars.packageName}` } },
+      test: run("test"),
+      lint: run("lint"),
+      doc: run("doc")
+    }
+  });
+}
+function libTsconfig() {
+  return toJson({
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      baseUrl: ".",
+      rootDir: ".",
+      outDir: "./dist",
+      module: "nodenext",
+      moduleResolution: "nodenext",
+      target: "es2024",
+      lib: ["es2024"],
+      noEmit: true,
+      emitDeclarationOnly: true,
+      sourceMap: true,
+      declaration: true,
+      declarationMap: true,
+      removeComments: false,
+      allowSyntheticDefaultImports: true,
+      importHelpers: true,
+      isolatedModules: true
+    },
+    exclude: ["./coverage/**", "./dist/**", "./doc/**", "./node_modules/**"]
+  });
+}
+function libTsconfigLib() {
+  return toJson({
+    extends: "./tsconfig.json",
+    compilerOptions: {
+      rootDir: "./src",
+      noEmit: false,
+      emitDeclarationOnly: false,
+      sourceMap: true,
+      declaration: true,
+      declarationMap: true,
+      removeComments: false
+    },
+    exclude: ["./coverage/**", "./dist/**", "./doc/**", "./node_modules/**", "./src/**/*.test.ts", "./src/_jest/**"]
+  });
+}
+function libTypedoc() {
+  return toJson({
+    extends: ["../../typedoc.json"],
+    entryPoints: ["./src"],
+    out: "doc",
+    exclude: ["./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+var indexTs2 = `export * from './greeter'
+`;
+var greeterTs = `/**
+ * Returns a friendly greeting for the given name.
+ *
+ * @remarks Demonstrates step-into-source debugging across internal libraries.
+ * @param name - The name to greet (surrounding whitespace is trimmed).
+ * @returns The greeting text.
+ * @throws Never - performs no I/O.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export function greet (name: string): string {
+  const trimmed = name.trim() // \u2190 set a breakpoint here, then run "Debug Jest (current file)"
+
+  return 'Hello, ' + trimmed + '!'
+}
+`;
+var greeterTestTs = `import { greet } from './index'
+
+describe('greet', () => {
+  it('greets a trimmed name', () => {
+    expect(greet('  Ada  ')).toBe('Hello, Ada!')
+  })
+})
+`;
+function internalLibFiles(vars) {
+  const root = `libs/${vars.name}`;
+  const toolOwned = (path, content) => ({ path: `${root}/${path}`, content, ownership: "tool-owned" });
+  const scaffold = (path, content) => ({ path: `${root}/${path}`, content, ownership: "scaffold" });
+  return [
+    scaffold("package.json", libPackageJson(vars)),
+    toolOwned("project.json", libProjectJson(vars)),
+    toolOwned("tsconfig.json", libTsconfig()),
+    toolOwned("tsconfig.lib.json", libTsconfigLib()),
+    scaffold("jest.config.mjs", `import { createConfig } from '../../jest.preset.mjs'
+
+export default createConfig('${vars.name}')
+`),
+    toolOwned("typedoc.json", libTypedoc()),
+    scaffold("src/index.ts", indexTs2),
+    scaffold("src/greeter.ts", greeterTs),
+    scaffold("src/greeter.test.ts", greeterTestTs)
+  ];
+}
+
+// src/templates/nextApp.ts
+var buildEnvScript = (environment) => `dotenv -e .env.${environment} -- node ../../tools/next-build.mjs ${environment}`;
+function appPackageJson3(vars) {
+  return toJson({
+    name: vars.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "next dev",
+      "build:dev": buildEnvScript("dev"),
+      "build:uat": buildEnvScript("uat"),
+      "build:prod": buildEnvScript("prod"),
+      "build:all": "npm run build:dev && npm run build:uat && npm run build:prod",
+      build: "npm run build:dev",
+      start: "next start",
+      lint: "eslint . -c ../../eslint.config.mjs",
+      test: "jest --collectCoverage"
+    }
+  });
+}
+function appProjectJson3(vars) {
+  const run = (target) => ({
+    executor: "nx:run-commands",
+    options: { command: `npm run ${target} -w ${vars.packageName}` }
+  });
+  return toJson({
+    name: vars.name,
+    $schema: "../../node_modules/nx/schemas/project-schema.json",
+    sourceRoot: `apps/${vars.name}/src`,
+    projectType: "application",
+    tags: [TAGS.nextjsApp],
+    targets: {
+      build: {
+        executor: "nx:run-commands",
+        outputs: ["{projectRoot}/dist-dev", "{projectRoot}/dist-uat", "{projectRoot}/dist-prod"],
+        options: { command: `npm run build -w ${vars.packageName}` }
+      },
+      serve: run("dev"),
+      test: run("test"),
+      lint: run("lint")
+    }
+  });
+}
+function appTsconfig3() {
+  return toJson({
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      target: "es2022",
+      lib: ["es2022", "dom", "dom.iterable"],
+      jsx: "preserve",
+      module: "esnext",
+      moduleResolution: "bundler",
+      types: ["node"],
+      noEmit: true,
+      allowJs: true,
+      esModuleInterop: true,
+      incremental: true,
+      plugins: [{ name: "next" }]
+    },
+    include: ["next-env.d.ts", "src", ".next/types/**/*.ts"],
+    exclude: ["node_modules"]
+  });
+}
+function appTypedoc3() {
+  return toJson({
+    extends: ["../../typedoc.json"],
+    entryPoints: ["./src"],
+    out: "doc",
+    exclude: ["./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+var nextConfig = `import path from 'node:path'
+
+// ESLint runs as its own monorepo target (npm run lint); Next type-checks the build.
+const nextConfig = { output: process.env.NEXT_OUTPUT === 'export' ? 'export' : 'standalone', outputFileTracingRoot: path.join(import.meta.dirname, '..', '..'), eslint: { ignoreDuringBuilds: true } }
+
+export default nextConfig
+`;
+function layoutTsx(vars) {
+  return `import type { ReactNode } from 'react'
+
+export const metadata = { title: '${vars.name}' }
+
+// Root layout required by the Next.js App Router; wraps every page.
+export default function RootLayout ({ children }: { children: ReactNode }) {
+  return (
+    <html lang='en'>
+      <body>{ children }</body>
+    </html>
+  )
+}
+`;
+}
+var pageTsx = `import { greet } from '../greeting'
+
+// Home page (App Router server component).
+export default function Home () {
+  return (
+    <main>
+      <h1>{greet('Next.js')}</h1>
+    </main>
+  )
+}
+`;
+var greetingTs3 = `/**
+ * Returns the greeting rendered on the home page.
+ *
+ * @remarks Shared TS logic \u2014 unit-tested directly (no Next.js test transform needed).
+ * @param name - The name to greet.
+ * @returns The greeting text.
+ * @throws Never - performs no I/O.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export function greet (name: string): string {
+  return 'Hello from ' + name + '!'
+}
+`;
+var greetingTestTs3 = `import { greet } from './greeting'
+
+describe('greet', () => {
+  it('greets the given name', () => {
+    expect(greet('world')).toBe('Hello from world!')
+  })
+})
+`;
+function envFile2(environment) {
+  return `NEXT_PUBLIC_ENVIRONMENT=${environment}
+NEXT_PUBLIC_API_URL=https://${environment}.example.com
+`;
+}
+function nextAppFiles(vars) {
+  const root = `apps/${vars.name}`;
+  const file = (path, content, ownership) => ({ path: `${root}/${path}`, content, ownership });
+  return [
+    file("package.json", appPackageJson3(vars), "scaffold"),
+    file("project.json", appProjectJson3(vars), "tool-owned"),
+    file("tsconfig.json", appTsconfig3(), "tool-owned"),
+    file("next.config.mjs", nextConfig, "scaffold"),
+    file("jest.config.mjs", `import { createConfig } from '../../jest.preset.mjs'
+
+export default createConfig('${vars.name}')
+`, "scaffold"),
+    file("typedoc.json", appTypedoc3(), "tool-owned"),
+    file(".env.dev", envFile2("dev"), "scaffold"),
+    file(".env.uat", envFile2("uat"), "scaffold"),
+    file(".env.prod", envFile2("prod"), "scaffold"),
+    file("src/app/layout.tsx", layoutTsx(vars), "scaffold"),
+    file("src/app/page.tsx", pageTsx, "scaffold"),
+    file("src/greeting.ts", greetingTs3, "scaffold"),
+    file("src/greeting.test.ts", greetingTestTs3, "scaffold"),
+    { path: "tools/next-build.mjs", content: readAsset("scripts/next-build.mjs"), ownership: "tool-owned" }
+  ];
+}
+
+// src/templates/nodeApp.ts
+function appPackageJson4(vars) {
+  return toJson({
+    name: vars.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "commonjs",
+    main: "dist/index.js",
+    dependencies: {},
+    scripts: {
+      build: "tsc -p tsconfig.app.json",
+      watch: "tsc -p tsconfig.app.json -w",
+      start: "node dist/index.js",
+      dev: "tsx watch src/index.ts",
+      lint: "eslint . -c ../../eslint.config.mjs",
+      test: "jest --collectCoverage",
+      doc: "typedoc --tsconfig tsconfig.app.json"
+    }
+  });
+}
+function appProjectJson4(vars) {
+  const run = (target) => ({
+    executor: "nx:run-commands",
+    options: { command: `npm run ${target} -w ${vars.packageName}` }
+  });
+  return toJson({
+    name: vars.name,
+    $schema: "../../node_modules/nx/schemas/project-schema.json",
+    sourceRoot: `apps/${vars.name}/src`,
+    projectType: "application",
+    tags: [TAGS.nodeApp],
+    targets: {
+      build: { executor: "nx:run-commands", outputs: ["{projectRoot}/dist"], options: { command: `npm run build -w ${vars.packageName}` } },
+      serve: run("start"),
+      test: run("test"),
+      lint: run("lint"),
+      doc: run("doc")
+    }
+  });
+}
+function appTsconfig4() {
+  return toJson({
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      baseUrl: ".",
+      rootDir: ".",
+      outDir: "./dist",
+      module: "commonjs",
+      moduleResolution: "node",
+      target: "es2022",
+      sourceMap: true,
+      declaration: false,
+      declarationMap: false,
+      esModuleInterop: true
+    },
+    exclude: ["./coverage/**", "./dist/**", "./doc/**", "./node_modules/**"]
+  });
+}
+function appTsconfigApp2() {
+  return toJson({
+    extends: "./tsconfig.json",
+    compilerOptions: {
+      rootDir: "./src",
+      noEmit: false,
+      sourceMap: true,
+      removeComments: false
+    },
+    exclude: ["./coverage/**", "./dist/**", "./doc/**", "./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+function appTypedoc4() {
+  return toJson({
+    extends: ["../../typedoc.json"],
+    entryPoints: ["./src"],
+    out: "doc",
+    exclude: ["./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+var serverTs = `import { IncomingMessage, ServerResponse } from 'node:http'
+
+/**
+ * Builds the greeting returned by the server.
+ *
+ * @remarks Pure string helper \u2014 replace with your own logic.
+ * @param name - The name to greet.
+ * @returns The greeting text.
+ * @throws Never - performs no I/O.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export function buildGreeting (name: string): string {
+  return 'Hello, ' + name + '!'
+}
+
+/**
+ * Handles an HTTP request, replying with a plain-text greeting.
+ *
+ * @remarks Swap in Express, Koa, Fastify, Nest or any framework you prefer.
+ * @param request - The incoming HTTP request.
+ * @param response - The HTTP response to write to.
+ * @returns Nothing.
+ * @throws Never - failures surface through the Node HTTP server.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export function handleRequest (request: IncomingMessage, response: ServerResponse): void {
+  const requestUrl = new URL(request.url ?? '/', 'http://localhost')
+  const name = requestUrl.searchParams.get('name') ?? 'world'
+
+  response.writeHead(200, { 'content-type': 'text/plain' })
+  response.end(buildGreeting(name))
+}
+`;
+var indexTs3 = `import { createServer } from 'node:http'
+import { handleRequest } from './server'
+
+const port = Number(process.env.PORT ?? 3000)
+
+createServer(handleRequest).listen(port, () => {
+  console.log('Server listening on http://localhost:' + port)
+})
+`;
+var serverTestTs = `import { buildGreeting } from './server'
+
+describe('buildGreeting', () => {
+  it('greets a name', () => {
+    expect(buildGreeting('world')).toBe('Hello, world!')
+  })
+})
+`;
+function nodeAppFiles(vars) {
+  const root = `apps/${vars.name}`;
+  const file = (path, content, ownership) => ({ path: `${root}/${path}`, content, ownership });
+  return [
+    file("package.json", appPackageJson4(vars), "scaffold"),
+    file("project.json", appProjectJson4(vars), "tool-owned"),
+    file("tsconfig.json", appTsconfig4(), "tool-owned"),
+    file("tsconfig.app.json", appTsconfigApp2(), "tool-owned"),
+    file("jest.config.mjs", `import { createConfig } from '../../jest.preset.mjs'
+
+export default createConfig('${vars.name}')
+`, "scaffold"),
+    file("typedoc.json", appTypedoc4(), "tool-owned"),
+    file("src/index.ts", indexTs3, "scaffold"),
+    file("src/server.ts", serverTs, "scaffold"),
+    file("src/server.test.ts", serverTestTs, "scaffold")
+  ];
+}
+
+// src/engine/registry.ts
+function registryUrl(registry) {
+  switch (registry.kind) {
+    case "azure-artifacts": {
+      return `https://pkgs.dev.azure.com/${registry.organization}/${registry.project}/_packaging/${registry.artifactsFeed}/npm/registry/`;
+    }
+    case "github-packages": {
+      return "https://npm.pkg.github.com/";
+    }
+    default: {
+      return void 0;
+    }
+  }
+}
+function npmrcContent(registry, scope) {
+  const scopeName = scope.replace(/^@/, "");
+  const url = registryUrl(registry);
+  const lines = [
+    "registry=https://registry.npmjs.org/",
+    "; ESLint 10 lands ahead of some plugins' peer ranges; accept the resolved tree.",
+    "legacy-peer-deps=true"
+  ];
+  if (url) {
+    const host = url.replace(/^https:\/\//, "");
+    lines.push(`@${scopeName}:registry=${url}`, `//${host}:_authToken=\${NODE_AUTH_TOKEN}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/templates/publishableLib.ts
+function publishConfig(vars) {
+  const url = vars.registry ? registryUrl(vars.registry) : void 0;
+  return url ? { registry: url } : void 0;
+}
+function tsconfig() {
+  return toJson({
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      baseUrl: ".",
+      rootDir: ".",
+      outDir: "./dist",
+      module: "nodenext",
+      moduleResolution: "nodenext",
+      target: "es2024",
+      lib: ["es2024"],
+      noEmit: true,
+      emitDeclarationOnly: true,
+      sourceMap: true,
+      declaration: true,
+      declarationMap: true,
+      removeComments: false,
+      allowSyntheticDefaultImports: true,
+      importHelpers: true,
+      isolatedModules: true
+    },
+    exclude: ["./coverage/**", "./dist/**", "./doc/**", "./node_modules/**"]
+  });
+}
+function tsconfigLib() {
+  return toJson({
+    extends: "./tsconfig.json",
+    compilerOptions: {
+      rootDir: "./src",
+      noEmit: false,
+      emitDeclarationOnly: false,
+      sourceMap: true,
+      declaration: true,
+      declarationMap: true,
+      removeComments: false
+    },
+    exclude: ["./coverage/**", "./dist/**", "./doc/**", "./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+function typedoc() {
+  return toJson({
+    extends: ["../../typedoc.json"],
+    entryPoints: ["./src"],
+    out: "doc",
+    exclude: ["./node_modules/**", "./src/**/*.test.ts"]
+  });
+}
+function projectJson(vars, buildCommand) {
+  const run = (target) => ({
+    executor: "nx:run-commands",
+    options: { command: `npm run ${target} -w ${vars.packageName}` }
+  });
+  return toJson({
+    name: vars.name,
+    $schema: "../../node_modules/nx/schemas/project-schema.json",
+    sourceRoot: `libs/${vars.name}/src`,
+    projectType: vars.kind === "cli-tool" ? "application" : "library",
+    tags: [TAGS.publishableLib],
+    targets: {
+      build: { executor: "nx:run-commands", outputs: ["{projectRoot}/dist"], options: { command: buildCommand } },
+      test: run("test"),
+      lint: run("lint"),
+      doc: run("doc")
+    }
+  });
+}
+var greeterTs2 = `/**
+ * Returns a friendly greeting for the given name.
+ *
+ * @remarks The package's public API entry point.
+ * @param name - The name to greet (surrounding whitespace is trimmed).
+ * @returns The greeting text.
+ * @throws Never - performs no I/O.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export function greet (name: string): string {
+  const trimmed = name.trim() // \u2190 breakpoint here works under "Debug Jest (current file)"
+
+  return 'Hello, ' + trimmed + '!'
+}
+`;
+var greeterTestTs2 = `import { greet } from './index'
+
+describe('greet', () => {
+  it('greets a trimmed name', () => {
+    expect(greet('  Ada  ')).toBe('Hello, Ada!')
+  })
+})
+`;
+function distPackageScript() {
+  return {
+    path: "tools/generate-dist-package.mjs",
+    content: readAsset("scripts/generate-dist-package.mjs"),
+    ownership: "tool-owned"
+  };
+}
+function publishableLibFiles(vars) {
+  const root = `libs/${vars.name}`;
+  const buildCommand = `npm run build -w ${vars.packageName}`;
+  const packageJson2 = toJson({
+    name: vars.packageName,
+    version: "0.0.0",
+    type: "commonjs",
+    main: "./src/index.ts",
+    types: "./src/index.ts",
+    publishConfig: publishConfig(vars),
+    monecromanci: { dist: { main: "./index.js", types: "./index.d.ts" } },
+    dependencies: {},
+    scripts: {
+      build: "tsc -p ./tsconfig.lib.json && node ../../tools/generate-dist-package.mjs",
+      test: "jest --collectCoverage",
+      lint: "eslint . -c ../../eslint.config.mjs",
+      doc: "typedoc --tsconfig tsconfig.lib.json",
+      publish: "npm publish ./dist"
+    }
+  });
+  const file = (path, content, ownership) => ({ path: `${root}/${path}`, content, ownership });
+  return [
+    file("package.json", packageJson2, "scaffold"),
+    file("project.json", projectJson(vars, buildCommand), "tool-owned"),
+    file("tsconfig.json", tsconfig(), "tool-owned"),
+    file("tsconfig.lib.json", tsconfigLib(), "tool-owned"),
+    file("jest.config.mjs", `import { createConfig } from '../../jest.preset.mjs'
+
+export default createConfig('${vars.name}')
+`, "scaffold"),
+    file("typedoc.json", typedoc(), "tool-owned"),
+    file("src/index.ts", "export * from './greeter'\n", "scaffold"),
+    file("src/greeter.ts", greeterTs2, "scaffold"),
+    file("src/greeter.test.ts", greeterTestTs2, "scaffold"),
+    distPackageScript()
+  ];
+}
+var cliMainTs = String.raw`/** Sample CLI entry point. Replace with your own command logic. */
+function main (argv: string[]): void {
+  const name = argv[0] ?? 'world'
+  process.stdout.write('Hello, ' + name + '!\n')
+}
+
+main(process.argv.slice(2))
+`;
+var cliMainTestTs = `import { greet } from './greeter'
+
+describe('greet', () => {
+  it('greets a name', () => {
+    expect(greet('world')).toBe('Hello, world!')
+  })
+})
+`;
+var cliGreeterTs = `/**
+ * Returns the greeting printed by the CLI.
+ *
+ * @remarks Replace with your own command logic.
+ * @param name - The name to greet.
+ * @returns The greeting text.
+ * @throws Never - performs no I/O.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export function greet (name: string): string {
+  return 'Hello, ' + name + '!'
+}
+`;
+function cliToolFiles(vars) {
+  const root = `libs/${vars.name}`;
+  const buildCommand = `npm run build -w ${vars.packageName}`;
+  const esbuild = "esbuild src/cli.ts --bundle --platform=node --target=node24 --outfile=dist/cli.js";
+  const packageJson2 = toJson({
+    name: vars.packageName,
+    version: "0.0.0",
+    type: "commonjs",
+    main: "./src/cli.ts",
+    bin: { [vars.name]: "./dist/cli.js" },
+    publishConfig: publishConfig(vars),
+    monecromanci: { dist: { main: "./cli.js", bin: { [vars.name]: "./cli.js" } } },
+    dependencies: {},
+    scripts: {
+      build: `${esbuild} && node ../../tools/generate-dist-package.mjs`,
+      test: "jest --collectCoverage",
+      lint: "eslint . -c ../../eslint.config.mjs",
+      doc: "typedoc --tsconfig tsconfig.lib.json",
+      publish: "npm publish ./dist"
+    }
+  });
+  const file = (path, content, ownership) => ({ path: `${root}/${path}`, content, ownership });
+  return [
+    file("package.json", packageJson2, "scaffold"),
+    file("project.json", projectJson(vars, buildCommand), "tool-owned"),
+    file("tsconfig.json", tsconfig(), "tool-owned"),
+    file("tsconfig.lib.json", tsconfigLib(), "tool-owned"),
+    file("jest.config.mjs", `import { createConfig } from '../../jest.preset.mjs'
+
+export default createConfig('${vars.name}')
+`, "scaffold"),
+    file("typedoc.json", typedoc(), "tool-owned"),
+    file("src/cli.ts", cliMainTs, "scaffold"),
+    file("src/greeter.ts", cliGreeterTs, "scaffold"),
+    file("src/greeter.test.ts", cliMainTestTs, "scaffold"),
+    distPackageScript()
+  ];
+}
+
+// src/templates/reactApp.ts
+function appPackageJson5(vars) {
+  return toJson({
+    name: vars.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      "build:dev": "vite build --mode dev --outDir dist-dev",
+      "build:uat": "vite build --mode uat --outDir dist-uat",
+      "build:prod": "vite build --mode prod --outDir dist-prod",
+      "build:all": "npm run build:dev && npm run build:uat && npm run build:prod",
+      build: "npm run build:dev",
+      preview: "vite preview",
+      lint: "eslint . -c ../../eslint.config.mjs",
+      test: "jest --collectCoverage"
+    }
+  });
+}
+function appProjectJson5(vars) {
+  const run = (target) => ({
+    executor: "nx:run-commands",
+    options: { command: `npm run ${target} -w ${vars.packageName}` }
+  });
+  return toJson({
+    name: vars.name,
+    $schema: "../../node_modules/nx/schemas/project-schema.json",
+    sourceRoot: `apps/${vars.name}/src`,
+    projectType: "application",
+    tags: [TAGS.reactApp],
+    targets: {
+      build: {
+        executor: "nx:run-commands",
+        outputs: ["{projectRoot}/dist-dev", "{projectRoot}/dist-uat", "{projectRoot}/dist-prod"],
+        options: { command: `npm run build -w ${vars.packageName}` }
+      },
+      serve: run("dev"),
+      test: run("test"),
+      lint: run("lint")
+    }
+  });
+}
+function appTsconfig5() {
+  return toJson({
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      target: "es2022",
+      lib: ["es2022", "DOM", "DOM.Iterable"],
+      module: "esnext",
+      moduleResolution: "bundler",
+      jsx: "react-jsx",
+      types: ["vite/client", "node"],
+      noEmit: true,
+      sourceMap: true,
+      allowSyntheticDefaultImports: true,
+      esModuleInterop: true
+    },
+    include: ["src", "vite.config.ts"]
+  });
+}
+function appTsconfigSpec() {
+  return toJson({
+    extends: "../../tsconfig.jest.json",
+    compilerOptions: {
+      jsx: "react-jsx",
+      module: "commonjs",
+      moduleResolution: "node",
+      types: ["jest", "node"]
+    }
+  });
+}
+var viteConfigTs = `import react from '@vitejs/plugin-react'
+import { defineConfig } from 'vite'
+
+export default defineConfig({ plugins: [react()], server: { port: 5173 }, build: { sourcemap: true } })
+`;
+var viteEnvDts = `/// <reference types="vite/client" />
+`;
+function indexHtml2(vars) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${vars.name}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+}
+var mainTsx = `import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { App } from './App'
+
+// Vite exposes the per-environment .env values on import.meta.env (build --mode).
+const environment = import.meta.env.VITE_ENVIRONMENT ?? 'local'
+console.info('Starting app in ' + environment + ' mode')
+
+createRoot(document.querySelector('#root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
+`;
+var appTsx = `/**
+ * Root application component.
+ *
+ * @remarks The app's UI entry point, rendered by main.tsx.
+ * @returns The rendered application markup.
+ * @throws Never - a pure render.
+ * @typeParam None - this component has no generic type parameters.
+ */
+export function App () {
+  return (
+    <main>
+      <h1>Hello from your new app</h1>
+    </main>
+  )
+}
+`;
+var appTestTsx = `import '@testing-library/jest-dom'
+import { render, screen } from '@testing-library/react'
+import { App } from './App'
+
+describe('App', () => {
+  it('renders a heading', () => {
+    render(<App />)
+    expect(screen.getByRole('heading')).toBeInTheDocument()
+  })
+})
+`;
+var jestConfigMjs = (name) => String.raw`import { createConfig } from '../../jest.preset.mjs'
+
+const base = createConfig('${name}')
+
+export default { ...base, testEnvironment: 'jsdom', transform: { '^.+\\.[tj]sx?$': ['ts-jest', { tsconfig: './tsconfig.spec.json' }] } }
+`;
+function envFile3(environment) {
+  return `VITE_ENVIRONMENT=${environment}
+VITE_API_URL=https://${environment}.example.com
+`;
+}
+function reactAppFiles(vars) {
+  const root = `apps/${vars.name}`;
+  const file = (path, content, ownership) => ({ path: `${root}/${path}`, content, ownership });
+  return [
+    file("package.json", appPackageJson5(vars), "scaffold"),
+    file("project.json", appProjectJson5(vars), "tool-owned"),
+    file("tsconfig.json", appTsconfig5(), "tool-owned"),
+    file("tsconfig.spec.json", appTsconfigSpec(), "tool-owned"),
+    file("vite.config.ts", viteConfigTs, "scaffold"),
+    file("index.html", indexHtml2(vars), "scaffold"),
+    file("jest.config.mjs", jestConfigMjs(vars.name), "scaffold"),
+    file(".env.dev", envFile3("dev"), "scaffold"),
+    file(".env.uat", envFile3("uat"), "scaffold"),
+    file(".env.prod", envFile3("prod"), "scaffold"),
+    file("src/vite-env.d.ts", viteEnvDts, "scaffold"),
+    file("src/main.tsx", mainTsx, "scaffold"),
+    file("src/App.tsx", appTsx, "scaffold"),
+    file("src/App.test.tsx", appTestTsx, "scaffold")
+  ];
+}
+
+// src/generators/scaffold.ts
+var ROOT_DEPENDENCIES = {
+  "function-app": {
+    dependencies: { "@azure/functions": "^4.16.0" }
+  },
+  "node-app": {
+    devDependencies: { tsx: "^4.20.6" }
+  },
+  "vue-app": {
+    dependencies: { vue: "^3.5.13" },
+    devDependencies: { "@vitejs/plugin-vue": "^5.2.4", vite: "^6.0.7" }
+  },
+  "svelte-app": {
+    devDependencies: { "@sveltejs/vite-plugin-svelte": "^5.0.3", svelte: "^5.19.0", vite: "^6.0.7" }
+  },
+  "nextjs-app": {
+    dependencies: { next: "^15.1.4", react: "^19.2.0", "react-dom": "^19.2.0" },
+    devDependencies: { "@types/react": "^19.2.0", "@types/react-dom": "^19.2.0", "dotenv-cli": "^8.0.0" }
+  },
+  "react-app": {
+    dependencies: { react: "^19.2.0", "react-dom": "^19.2.0" },
+    devDependencies: {
+      "@testing-library/dom": "^10.4.0",
+      "@testing-library/jest-dom": "^6.6.3",
+      "@testing-library/react": "^16.1.0",
+      "@types/react": "^19.2.0",
+      "@types/react-dom": "^19.2.0",
+      "@vitejs/plugin-react": "^4.3.4",
+      "jest-environment-jsdom": "^30.0.0",
+      vite: "^6.0.7"
+    }
+  }
+};
+function filesForKind(kind, vars) {
+  switch (kind) {
+    case "internal-lib": {
+      return internalLibFiles(vars);
+    }
+    case "publishable-lib": {
+      return publishableLibFiles(vars);
+    }
+    case "cli-tool": {
+      return cliToolFiles(vars);
+    }
+    case "function-app": {
+      return functionAppFiles(vars);
+    }
+    case "node-app": {
+      return nodeAppFiles(vars);
+    }
+    case "react-app": {
+      return reactAppFiles(vars);
+    }
+    case "vue-app": {
+      return vueAppFiles(vars);
+    }
+    case "svelte-app": {
+      return svelteAppFiles(vars);
+    }
+    case "nextjs-app": {
+      return nextAppFiles(vars);
+    }
+    default: {
+      throw new Error(`The '${kind}' generator is not implemented yet.`);
+    }
+  }
+}
+function projectFiles(kind, vars) {
+  return filesForKind(kind, vars);
+}
+function applyRootDependencies(repoRoot, kind) {
+  const root = ROOT_DEPENDENCIES[kind];
+  if (!root) {
+    return;
+  }
+  const added = [
+    ...root.dependencies ? addRootDependencies(repoRoot, root.dependencies, "dependencies") : [],
+    ...root.devDependencies ? addRootDependencies(repoRoot, root.devDependencies, "devDependencies") : []
+  ];
+  if (added.length > 0) {
+    logger.step(`added root dependencies: ${added.join(", ")}`);
+  }
+}
+function generateProject(repoRoot, kind, name, config) {
+  const vars = {
+    kind,
+    name,
+    packageName: `${config.scope}/${name}`,
+    scope: config.scope,
+    registry: config.registry
+  };
+  logger.step(`Adding ${kind} '${name}' (${vars.packageName})`);
+  reportApply(applyFiles(repoRoot, filesForKind(kind, vars)));
+  applyRootDependencies(repoRoot, kind);
+}
+
+// src/generators/addProject.ts
+async function runAdd(options) {
+  const repoRoot = process.cwd();
+  if (!isManagedRepo(repoRoot)) {
+    logger.error("No .monecromanci.json found here. Run this from the monorepo root, or create one with `monecromanci new`.");
+    return;
+  }
+  const config = loadConfig(repoRoot);
+  if (!config) {
+    logger.error("Could not read .monecromanci.json.");
+    return;
+  }
+  const kind = options.type ?? await (0, import_prompts2.select)({
+    message: "What do you want to add?",
+    choices: [
+      { name: "Internal library", value: "internal-lib" },
+      { name: "Publishable library", value: "publishable-lib" },
+      { name: "CLI tool", value: "cli-tool" },
+      { name: "Azure Function App", value: "function-app" },
+      { name: "Node.js app (generic server)", value: "node-app" },
+      { name: "React app", value: "react-app" },
+      { name: "Vue app", value: "vue-app" },
+      { name: "Svelte app", value: "svelte-app" },
+      { name: "Next.js app (full-stack)", value: "nextjs-app" }
+    ]
+  });
+  const name = toSlug(options.name ?? await promptText("Project name"));
+  generateProject(repoRoot, kind, name, config);
+  logger.success("Done. Run `npm install` to link the new workspace, then `npm run graph`.");
+}
+
+// src/engine/projects.ts
+var import_node_fs4 = require("fs");
+var import_node_path6 = require("path");
+function readTags(projectJson2) {
+  return Array.isArray(projectJson2.tags) ? projectJson2.tags.map(String) : [];
+}
+function hasBin(packageJson2) {
+  if (packageJson2.bin) {
+    return true;
+  }
+  const marker = packageJson2.monecromanci;
+  return Boolean(marker?.dist?.bin);
+}
+function kindFromProject(projectJson2, packageJson2) {
+  const tags = readTags(projectJson2);
+  if (tags.includes(TAGS.functionApp)) {
+    return "function-app";
+  }
+  if (tags.includes(TAGS.nodeApp)) {
+    return "node-app";
+  }
+  if (tags.includes(TAGS.reactApp)) {
+    return "react-app";
+  }
+  if (tags.includes(TAGS.vueApp)) {
+    return "vue-app";
+  }
+  if (tags.includes(TAGS.svelteApp)) {
+    return "svelte-app";
+  }
+  if (tags.includes(TAGS.nextjsApp)) {
+    return "nextjs-app";
+  }
+  if (tags.includes(TAGS.internalLib)) {
+    return "internal-lib";
+  }
+  if (tags.includes(TAGS.publishableLib)) {
+    return hasBin(packageJson2) ? "cli-tool" : "publishable-lib";
+  }
+  return void 0;
+}
+function scanArea(areaDirectory, config) {
+  const projects = [];
+  const entries = (0, import_node_fs4.readdirSync)(areaDirectory, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const projectDirectory = (0, import_node_path6.join)(areaDirectory, entry.name);
+    const projectJson2 = readJsonSafe((0, import_node_path6.join)(projectDirectory, "project.json"), {});
+    const packageJson2 = readJsonSafe((0, import_node_path6.join)(projectDirectory, "package.json"), {});
+    const kind = kindFromProject(projectJson2, packageJson2);
+    if (!kind) {
+      continue;
+    }
+    const packageName = typeof packageJson2.name === "string" ? packageJson2.name : `${config.scope}/${entry.name}`;
+    projects.push({ kind, name: entry.name, packageName, scope: config.scope, registry: config.registry });
+  }
+  return projects;
+}
+function discoverProjects(repoRoot, config) {
+  const projects = [];
+  for (const area of ["apps", "libs"]) {
+    const areaDirectory = (0, import_node_path6.join)(repoRoot, area);
+    if ((0, import_node_fs4.existsSync)(areaDirectory)) {
+      projects.push(...scanArea(areaDirectory, config));
+    }
+  }
+  return projects;
+}
+
+// src/engine/sync.ts
+var import_node_path7 = require("path");
+function checkFile(repoRoot, spec) {
+  const absolute = (0, import_node_path7.join)(repoRoot, spec.path);
+  if (!(0, import_node_fs2.existsSync)(absolute)) {
+    return "missing";
+  }
+  return readTextSafe(absolute) === spec.content ? "ok" : "drift";
+}
+function syncToolOwned(repoRoot, specs, shouldApply) {
+  const report = { ok: [], missing: [], drift: [], fixed: [] };
+  for (const spec of specs) {
+    if (spec.ownership !== "tool-owned") {
+      continue;
+    }
+    const status = checkFile(repoRoot, spec);
+    if (status === "ok") {
+      report.ok.push(spec.path);
+      continue;
+    }
+    if (status === "missing") {
+      report.missing.push(spec.path);
+    } else {
+      report.drift.push(spec.path);
+    }
+    if (shouldApply) {
+      writeFileEnsured((0, import_node_path7.join)(repoRoot, spec.path), spec.content);
+      report.fixed.push(spec.path);
+    }
+  }
+  return report;
+}
+
+// package.json
+var package_default = {
+  name: "monecromanci",
+  version: "0.0.0",
+  description: "MoNecromanCI \u2014 interactive CLI to summon, conjure, raise and validate NX monorepos (Azure DevOps & GitHub Actions): function/node apps, React/Vue/Svelte/Next.js apps, internal/publishable libs, CLI tools.",
+  bin: {
+    monecromanci: "./dist/cli.js",
+    mnci: "./dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: "^22.13.0 || >=24"
+  },
+  scripts: {
+    build: "tsup && node scripts/copyAssets.mjs",
+    dev: "tsup --watch",
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+    test: "jest",
+    "test:cov": "jest --coverage",
+    typecheck: "tsc --noEmit",
+    start: "node dist/cli.js"
+  },
+  keywords: [
+    "nx",
+    "monorepo",
+    "azure-devops",
+    "cli",
+    "scaffold",
+    "typescript"
+  ],
+  author: "Eduardo Russo",
+  license: "MIT",
+  dependencies: {
+    "@inquirer/prompts": "^8.5.2",
+    commander: "^15.0.0"
+  },
+  devDependencies: {
+    "@eslint/markdown": "^8.0.2",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.0.1",
+    eslint: "^10.6.0",
+    "eslint-plugin-jest": "^29.15.3",
+    "eslint-plugin-jsonc": "^3.2.0",
+    "eslint-plugin-n": "^18.2.1",
+    "eslint-plugin-promise": "^7.3.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.3",
+    "eslint-plugin-tsdoc": "^0.5.2",
+    "eslint-plugin-tsdoc-require-2": "^1.2.3",
+    "eslint-plugin-unicorn": "^69.0.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "eslint-plugin-yml": "^3.5.0",
+    globals: "^17.7.0",
+    jest: "^30.4.2",
+    "ts-jest": "^29.4.11",
+    tsup: "^8.5.1",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.62.0"
+  }
+};
+
+// src/templates/monorepo.ts
+var sharedDependency = (name) => package_default.devDependencies[name];
+var DEV_DEPENDENCIES = {
+  "@commitlint/cli": "^21.1.0",
+  "@commitlint/config-conventional": "^21.1.0",
+  "@eslint/markdown": sharedDependency("@eslint/markdown"),
+  "@stylistic/eslint-plugin": sharedDependency("@stylistic/eslint-plugin"),
+  "@types/jest": sharedDependency("@types/jest"),
+  "@types/node": sharedDependency("@types/node"),
+  esbuild: "^0.28.1",
+  eslint: sharedDependency("eslint"),
+  "eslint-plugin-jest": sharedDependency("eslint-plugin-jest"),
+  "eslint-plugin-jsonc": sharedDependency("eslint-plugin-jsonc"),
+  "eslint-plugin-n": sharedDependency("eslint-plugin-n"),
+  "eslint-plugin-promise": sharedDependency("eslint-plugin-promise"),
+  "eslint-plugin-react": sharedDependency("eslint-plugin-react"),
+  "eslint-plugin-react-hooks": sharedDependency("eslint-plugin-react-hooks"),
+  "eslint-plugin-react-refresh": sharedDependency("eslint-plugin-react-refresh"),
+  "eslint-plugin-tsdoc": sharedDependency("eslint-plugin-tsdoc"),
+  "eslint-plugin-tsdoc-require-2": sharedDependency("eslint-plugin-tsdoc-require-2"),
+  "eslint-plugin-unicorn": sharedDependency("eslint-plugin-unicorn"),
+  "eslint-plugin-unused-imports": sharedDependency("eslint-plugin-unused-imports"),
+  "eslint-plugin-yml": sharedDependency("eslint-plugin-yml"),
+  globals: sharedDependency("globals"),
+  husky: "^9.1.7",
+  jest: sharedDependency("jest"),
+  "jest-junit": "^17.0.0",
+  nx: "^23.0.1",
+  "ts-jest": sharedDependency("ts-jest"),
+  "tsc-alias": "^1.8.17",
+  tslib: "^2.8.1",
+  typedoc: "^0.28.19",
+  "typedoc-plugin-missing-exports": "^4.1.3",
+  typescript: sharedDependency("typescript"),
+  "typescript-eslint": sharedDependency("typescript-eslint")
+};
+function packageJson(vars) {
+  return toJson({
+    name: vars.workspaceName,
+    version: "0.0.0",
+    private: true,
+    license: "UNLICENSED",
+    workspaces: ["apps/*", "libs/*"],
+    scripts: {
+      build: "nx run-many -t build --all",
+      "build:affected": "nx affected -t build",
+      lint: "nx run-many -t lint --all",
+      "lint:affected": "nx affected -t lint",
+      test: "nx run-many -t test --all",
+      "test:affected": "nx affected -t test",
+      doc: "nx run-many -t doc --all",
+      "doc:affected": "nx affected -t doc",
+      affected: "nx affected -t lint,test,build",
+      projects: "nx show projects",
+      graph: "nx graph",
+      "nx:reset": "nx reset",
+      "pipeline:plan": "node .build-templates/01-preparation.mjs",
+      "pipeline:package": "node .build-templates/03-package-apps.mjs --dry-run",
+      release: "nx release",
+      "release:version": "nx release version",
+      "release:publish": "nx release publish",
+      prepare: "husky"
+    },
+    dependencies: {
+      tslib: "^2.8.1"
+    },
+    devDependencies: DEV_DEPENDENCIES,
+    engines: {
+      node: `>=${vars.nodeVersion}`
+    }
+  });
+}
+function nxJson(vars) {
+  return toJson({
+    $schema: "./node_modules/nx/schemas/nx-schema.json",
+    workspaceLayout: { appsDir: "apps", libsDir: "libs" },
+    defaultBase: vars.defaultBase,
+    namedInputs: {
+      sharedGlobals: [
+        "{workspaceRoot}/package.json",
+        "{workspaceRoot}/package-lock.json",
+        "{workspaceRoot}/nx.json",
+        "{workspaceRoot}/tsconfig.base.json",
+        "{workspaceRoot}/jest.preset.mjs",
+        "{workspaceRoot}/eslint.config.mjs"
+      ],
+      default: ["{projectRoot}/**/*", "sharedGlobals"],
+      production: [
+        "default",
+        "!{projectRoot}/coverage/**",
+        "!{projectRoot}/dist/**",
+        "!{projectRoot}/doc/**",
+        "!{projectRoot}/**/*.test.ts",
+        "!{projectRoot}/src/_jest/**"
+      ]
+    },
+    targetDefaults: {
+      build: { dependsOn: ["^build"], inputs: ["production", "^production"], cache: true },
+      lint: { inputs: ["default", "^production"], cache: true },
+      test: { dependsOn: ["build"], inputs: ["default", "^production"], cache: true },
+      doc: { inputs: ["production", "^production"], cache: true }
+    },
+    release: {
+      projectsRelationship: "independent",
+      projects: ["tag:type:publishable-lib"],
+      releaseTagPattern: "{projectName}@{version}",
+      version: { conventionalCommits: true },
+      changelog: { projectChangelogs: true }
+    },
+    analytics: false
+  });
+}
+function tsconfigBase() {
+  return toJson({
+    $schema: "https://json.schemastore.org/tsconfig",
+    compilerOptions: {
+      ignoreDeprecations: "6.0",
+      target: "es2024",
+      types: ["jest", "node"],
+      sourceMap: true,
+      declaration: true,
+      declarationMap: true,
+      removeComments: false,
+      forceConsistentCasingInFileNames: true,
+      isolatedModules: true,
+      noFallthroughCasesInSwitch: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      resolveJsonModule: true,
+      skipLibCheck: true,
+      strict: true,
+      strictNullChecks: true,
+      strictPropertyInitialization: false
+    }
+  });
+}
+function tsconfigJest() {
+  return toJson({
+    extends: "./tsconfig.base.json",
+    compilerOptions: {
+      target: "es2022",
+      module: "commonjs",
+      moduleResolution: "node",
+      noEmit: false,
+      emitDeclarationOnly: false,
+      declaration: false,
+      declarationMap: false,
+      sourceMap: true,
+      esModuleInterop: true
+    }
+  });
+}
+function typedocJson() {
+  return toJson({
+    $schema: "https://typedoc.org/schema.json",
+    entryPointStrategy: "expand",
+    plugin: ["typedoc-plugin-missing-exports"],
+    excludePrivate: false,
+    categorizeByGroup: true,
+    cleanOutputDir: true
+  });
+}
+var jestConfigMjs2 = String.raw`import { globSync } from 'node:fs'
+
+const projects = globSync('{libs,apps}/*/jest.config.mjs').map((path) => path.replaceAll('\\', '/'))
+
+export default {
+  projects: projects.length > 0 ? projects : ['<rootDir>'],
+  maxWorkers: '75%',
+}
+`;
+var jestPresetMjs = String.raw`/** Shared Jest preset — generated by MoNecromanCI. Re-sync with 'monecromanci doctor'. */
+export function createConfig (projectName) {
+  return {
+    displayName:        projectName,
+    testEnvironment:    'node',
+    rootDir:            '.',
+    roots:              ['<rootDir>/src'],
+    setupFilesAfterEnv: [
+      '<rootDir>/../../jest.setup.mjs',
+      '<rootDir>/../../jest.clear.mjs',
+    ],
+    transform: {
+      '^.+\\.[tj]sx?$': ['ts-jest', { tsconfig: '<rootDir>/../../tsconfig.jest.json' }],
+    },
+    moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs', 'json'],
+    collectCoverageFrom:  [
+      '<rootDir>/src/**/*.ts',
+      '!<rootDir>/src/**/*.d.ts',
+      '!<rootDir>/src/index.ts',
+    ],
+    coverageProvider:  'v8',
+    coverageDirectory: './coverage',
+    coverageReporters: ['text', 'cobertura', 'html', 'lcov'],
+    reporters:         [
+      'default',
+      ['jest-junit', { outputDirectory: './coverage', outputName: 'test-results.xml' }],
+    ],
+  }
+}
+`;
+var jestSetupMjs = `process.env.TZ = 'UTC'
+
+beforeAll(() => {
+  jest.useFakeTimers()
+  jest.setSystemTime(new Date('2000-01-01T00:00:00.000Z'))
+})
+
+afterAll(() => {
+  jest.useRealTimers()
+})
+`;
+var jestClearMjs = `afterEach(() => {
+  jest.restoreAllMocks()
+  jest.clearAllMocks()
+  jest.resetModules()
+})
+`;
+function npmrc(vars) {
+  return npmrcContent(vars.registry, vars.scope);
+}
+var editorconfig = `root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+`;
+var gitignore = `node_modules/
+dist/
+dist-dev/
+dist-uat/
+dist-prod/
+coverage/
+doc/
+.nx/
+tmp/
+.azurite/
+.next/
+next-env.d.ts
+.pipeline-out/
+.pipeline-staging/
+*.log
+.DS_Store
+local.settings.json
+`;
+var commitlintConfigMjs = `export default {
+  extends: ['@commitlint/config-conventional'],
+}
+`;
+var huskyCommitMessage = `npx --no -- commitlint --edit "$1"
+`;
+function readme(vars) {
+  return `# ${vars.displayName}
+
+NX monorepo generated by [MoNecromanCI](https://github.com/russoedu/monecromanci).
+
+## Common commands
+
+\`\`\`sh
+npm run build          # build all projects
+npm run test           # run all tests
+npm run lint           # lint everything
+npm run affected       # lint + test + build only what changed
+npm run graph          # open the project graph
+\`\`\`
+
+## Debugging
+
+Open \`${vars.displayName}.code-workspace\` in VSCode. Use the **Run and Debug** panel:
+breakpoints work in \`.ts\` test files (and step into internal libs). The
+\`Orta.vscode-jest\` extension also adds a **Debug** lens above each test.
+
+## Adding projects
+
+\`\`\`sh
+npx monecromanci add    # (alias: conjure) function-app | node-app | react-app | vue-app | svelte-app | nextjs-app | internal-lib | publishable-lib | cli-tool
+\`\`\`
+`;
+}
+function registryLabelFor(registry) {
+  switch (registry.kind) {
+    case "azure-artifacts": {
+      return "the Azure Artifacts feed `" + registry.artifactsFeed + "`";
+    }
+    case "github-packages": {
+      return "GitHub Packages";
+    }
+    default: {
+      return "the public npm registry";
+    }
+  }
+}
+function nxReleaseDocument(vars) {
+  const registryLabel = registryLabelFor(vars.registry);
+  return `# Releasing publishable libraries & CLI tools
+
+This monorepo uses **\`nx release\`** with **independent** versioning driven by
+**Conventional Commits**. Only projects tagged \`type:publishable-lib\` (libraries
+and CLI tools) are released; internal libs and apps are never published.
+
+## How versions are decided (auto-bump)
+
+You do **not** hand-edit \`version\` in any \`package.json\`. \`nx release\` reads the
+Conventional Commit messages since each project's last release tag and bumps:
+
+| Commit type            | Bump   |
+| ---------------------- | ------ |
+| \`fix: \u2026\`               | patch  |
+| \`feat: \u2026\`              | minor  |
+| \`feat!: \u2026\` / \`BREAKING CHANGE\` | major |
+
+Commit messages are enforced by commitlint (\`commitlint.config.mjs\`) via a husky
+\`commit-msg\` hook, so the history stays releasable. Scope a commit to a project
+with \`fix(my-lib): \u2026\`.
+
+## Local commands
+
+\`\`\`sh
+npm run release            # interactive: version + changelog + (optional) publish
+npm run release:version    # bump versions + write changelogs from commits
+npm run release:publish    # publish what changed to the configured registry
+npx nx release --dry-run   # preview everything, change nothing
+\`\`\`
+
+## What gets published
+
+\`build\` emits \`dist/\` and runs \`tools/generate-dist-package.mjs\`, which writes a
+correct \`dist/package.json\`: it resolves real dependency versions from the **root**
+package.json (all deps live there) and from internal workspace packages. This is
+why published packages declare their dependencies even though project
+\`package.json\` files keep \`dependencies: {}\`. Publishing runs \`npm publish ./dist\`.
+
+## First release
+
+For a project that has never been released, set its starting version once:
+
+\`\`\`sh
+npx nx release version 1.0.0 --projects=my-lib --first-release
+\`\`\`
+
+## CI
+
+On \`${vars.defaultBase}\` (non-PR builds), CI runs \`nx release version --yes\`
+then publishes affected publishable projects to ${registryLabel}. See the publish
+step (\`04-publish-libs\`, or the GitHub Actions \`publish\` job).
+`;
+}
+function codeWorkspace(vars) {
+  return toJson({
+    folders: [{ path: ".", name: vars.displayName }],
+    settings: {
+      "eslint.useFlatConfig": true,
+      "eslint.validate": ["javascript", "typescript", "typescriptreact", "json", "jsonc", "json5", "yaml", "markdown"],
+      "files.exclude": {
+        "**/.nx": true,
+        "**/node_modules": true,
+        "**/coverage": true,
+        "**/.azurite": true,
+        tmp: true
+      },
+      "typescript.tsdk": "node_modules/typescript/lib",
+      "jest.runMode": "on-demand"
+    },
+    extensions: {
+      recommendations: [
+        "dbaeumer.vscode-eslint",
+        "orta.vscode-jest",
+        "ms-azuretools.vscode-azurefunctions",
+        "ms-edgedevtools.vscode-edge-devtools"
+      ]
+    },
+    // NOTE: launch/tasks are TOP-LEVEL workspace keys (NOT under settings) so VSCode surfaces them.
+    launch: {
+      version: "0.2.0",
+      configurations: [
+        // --- breakpoint-capable debug configs ---
+        {
+          name: "Debug Jest (current file)",
+          type: "node",
+          request: "launch",
+          program: "${workspaceFolder}/node_modules/jest/bin/jest.js",
+          args: ["--runInBand", "--watchAll=false", "--runTestsByPath", "${relativeFile}"],
+          cwd: "${workspaceFolder}",
+          console: "integratedTerminal",
+          internalConsoleOptions: "neverOpen",
+          disableOptimisticBPs: true,
+          resolveSourceMapLocations: null,
+          sourceMaps: true
+        },
+        {
+          name: "Debug Jest (all)",
+          type: "node",
+          request: "launch",
+          program: "${workspaceFolder}/node_modules/jest/bin/jest.js",
+          args: ["--runInBand", "--watchAll=false"],
+          cwd: "${workspaceFolder}",
+          console: "integratedTerminal",
+          internalConsoleOptions: "neverOpen",
+          disableOptimisticBPs: true,
+          resolveSourceMapLocations: null,
+          sourceMaps: true
+        },
+        {
+          // Function App: run `func start` (inspects via local.settings.json), then attach.
+          // Node app: run `node --inspect=9229 dist/index.js` (after build), then attach;
+          // or run `npm run dev -w <app>` in a JavaScript Debug Terminal for source-level tsx.
+          name: "Debug Function/Node App (attach :9229)",
+          type: "node",
+          request: "attach",
+          port: 9229,
+          restart: true,
+          sourceMaps: true,
+          resolveSourceMapLocations: null,
+          outFiles: ["${workspaceFolder}/apps/*/dist/**/*.js"],
+          skipFiles: ["<node_internals>/**"]
+        },
+        {
+          // Start the dev server first (`npm run dev -w <app>`), then launch the browser.
+          // Or use the JavaScript Debug Terminal: run `npm run dev -w <app>` there.
+          name: "Debug React/Vue/Svelte (Edge)",
+          type: "msedge",
+          request: "launch",
+          url: "http://localhost:5173",
+          webRoot: "${workspaceFolder}",
+          sourceMaps: true,
+          resolveSourceMapLocations: null
+        },
+        {
+          // Next.js dev server runs on :3000. For server-side breakpoints, run
+          // `npm run dev -w <app>` in a JavaScript Debug Terminal instead.
+          name: "Debug Next.js (Edge)",
+          type: "msedge",
+          request: "launch",
+          url: "http://localhost:3000",
+          webRoot: "${workspaceFolder}",
+          sourceMaps: true,
+          resolveSourceMapLocations: null
+        },
+        // --- convenience run configs (no breakpoints; quick npm scripts) ---
+        { name: "Run: build (all)", type: "node-terminal", request: "launch", command: "npm run build" },
+        { name: "Run: build (affected)", type: "node-terminal", request: "launch", command: "npm run build:affected" },
+        { name: "Run: test (all)", type: "node-terminal", request: "launch", command: "npm run test" },
+        { name: "Run: lint (all)", type: "node-terminal", request: "launch", command: "npm run lint" },
+        { name: "Run: docs (all)", type: "node-terminal", request: "launch", command: "npm run doc" },
+        { name: "Run: graph", type: "node-terminal", request: "launch", command: "npm run graph" }
+      ]
+    },
+    tasks: {
+      version: "2.0.0",
+      tasks: [
+        { label: "build all", type: "shell", command: "npm run build", problemMatcher: ["$tsc"] },
+        { label: "test all", type: "shell", command: "npm run test", problemMatcher: [] },
+        { label: "lint all", type: "shell", command: "npm run lint", problemMatcher: [] }
+      ]
+    }
+  });
+}
+function pipelineFiles(vars) {
+  const files = Array.from(listAssetFiles("build-templates"), (relativePath) => ({
+    path: `.build-templates/${relativePath}`,
+    content: readAsset(`build-templates/${relativePath}`),
+    ownership: "tool-owned"
+  }));
+  if (vars.ci === "azure" || vars.ci === "both") {
+    files.push({ path: "azure-pipelines.yml", content: readAsset("azure-pipelines.yml"), ownership: "tool-owned" });
+  }
+  if (vars.ci === "github" || vars.ci === "both") {
+    files.push({ path: ".github/workflows/ci.yml", content: readAsset("github/workflows/ci.yml"), ownership: "tool-owned" });
+  }
+  return files;
+}
+function monorepoFiles(vars) {
+  const toolOwned = (path, content) => ({ path, content, ownership: "tool-owned" });
+  const scaffold = (path, content) => ({ path, content, ownership: "scaffold" });
+  return [
+    scaffold("package.json", packageJson(vars)),
+    toolOwned("nx.json", nxJson(vars)),
+    toolOwned("tsconfig.base.json", tsconfigBase()),
+    toolOwned("tsconfig.jest.json", tsconfigJest()),
+    toolOwned("jest.config.mjs", jestConfigMjs2),
+    toolOwned("jest.preset.mjs", jestPresetMjs),
+    toolOwned("jest.setup.mjs", jestSetupMjs),
+    toolOwned("jest.clear.mjs", jestClearMjs),
+    toolOwned("eslint.config.mjs", readAsset("eslint.config.mjs")),
+    toolOwned("typedoc.json", typedocJson()),
+    scaffold(".npmrc", npmrc(vars)),
+    toolOwned(".editorconfig", editorconfig),
+    scaffold(".gitignore", gitignore),
+    toolOwned("commitlint.config.mjs", commitlintConfigMjs),
+    scaffold(".husky/commit-msg", huskyCommitMessage),
+    scaffold("README.md", readme(vars)),
+    scaffold("docs/nx-release.md", nxReleaseDocument(vars)),
+    toolOwned(`${vars.displayName}.code-workspace`, codeWorkspace(vars)),
+    ...pipelineFiles(vars),
+    // Keep apps/ and libs/ present even before any project is added.
+    scaffold("apps/.gitkeep", ""),
+    scaffold("libs/.gitkeep", "")
+  ];
+}
+
+// src/commands/doctor.ts
+async function runDoctor(options) {
+  const repoRoot = process.cwd();
+  if (!isManagedRepo(repoRoot)) {
+    logger.error("No .monecromanci.json found here. Run `doctor` from a MoNecromanCI monorepo root.");
+    return;
+  }
+  const config = loadConfig(repoRoot);
+  if (!config) {
+    logger.error("Could not read .monecromanci.json.");
+    return;
+  }
+  const vars = {
+    workspaceName: config.workspaceName,
+    displayName: config.displayName,
+    scope: config.scope,
+    defaultBase: config.defaultBase,
+    nodeVersion: config.nodeVersion,
+    ci: config.ci,
+    registry: config.registry
+  };
+  const specs = [...monorepoFiles(vars)];
+  for (const project of discoverProjects(repoRoot, config)) {
+    specs.push(...projectFiles(project.kind, project));
+  }
+  const report = syncToolOwned(repoRoot, specs, options.apply);
+  for (const path of report.missing) {
+    logger.warn(`missing: ${path}`);
+  }
+  for (const path of report.drift) {
+    logger.warn(`drift:   ${path}`);
+  }
+  for (const path of report.fixed) {
+    logger.success(`fixed:   ${path}`);
+  }
+  const issues = report.missing.length + report.drift.length;
+  if (issues === 0) {
+    logger.success(`Everything is in sync (${report.ok.length} tool-owned files checked).`);
+    return;
+  }
+  if (!options.apply) {
+    logger.info(`${issues} issue(s) found. Re-run with --fix to repair (scaffold files are left untouched).`);
+    return;
+  }
+  saveConfig(repoRoot, { ...config, templateVersion: TEMPLATE_VERSION });
+  logger.success(`Repaired ${report.fixed.length} file(s); stamped template version ${TEMPLATE_VERSION}.`);
+}
+
+// src/generators/createMonorepo.ts
+var import_node_path8 = require("path");
+async function runNew(options) {
+  const yes = options.yes ?? false;
+  const ask = async (message, fallback, provided) => provided ?? (yes ? fallback : await promptText(message, fallback));
+  const askChoice = async (message, choices, fallback, provided) => provided ?? (yes ? fallback : await (0, import_prompts2.select)({ message, choices }));
+  const displayName = await ask("Monorepo name", "My Monorepo", options.name);
+  const workspaceName = toSlug(displayName);
+  const ci = await askChoice("CI provider", [
+    { name: "Azure DevOps Pipelines", value: "azure" },
+    { name: "GitHub Actions", value: "github" },
+    { name: "Both", value: "both" }
+  ], "azure", options.ci);
+  const registry = await resolveRegistry(ci, options, ask, askChoice);
+  const defaultScope = registry.kind === "github-packages" ? `@${registry.owner}` : "@auto";
+  const scopeInput = await ask("npm scope", defaultScope, options.scope);
+  const scope = scopeInput.startsWith("@") ? scopeInput : `@${scopeInput}`;
+  const defaultBase = await ask("Default git branch", DEFAULT_BASE, options.base);
+  const targetDirectory = (0, import_node_path8.resolve)(process.cwd(), workspaceName);
+  if ((0, import_node_fs2.existsSync)((0, import_node_path8.join)(targetDirectory, "package.json")) && !yes) {
+    const overwrite = await (0, import_prompts2.confirm)({ message: `${targetDirectory} already contains a package.json. Continue and overwrite tool-owned files?`, default: false });
+    if (!overwrite) {
+      logger.warn("Aborted.");
+      return;
+    }
+  }
+  const vars = {
+    workspaceName,
+    displayName,
+    scope,
+    defaultBase,
+    nodeVersion: DEFAULT_NODE_VERSION,
+    ci,
+    registry
+  };
+  logger.step(`Creating monorepo in ${targetDirectory}`);
+  reportApply(applyFiles(targetDirectory, monorepoFiles(vars)));
+  saveConfig(targetDirectory, configFromVars(vars));
+  const libName = await resolveInitialLib(options.lib, yes);
+  if (libName) {
+    generateProject(targetDirectory, "internal-lib", libName, configFromVars(vars));
+  }
+  logger.success("Done. Next steps:");
+  logger.info(`  cd ${workspaceName}`);
+  logger.info("  npm install");
+  logger.info(`  code "${displayName}.code-workspace"`);
+}
+async function resolveRegistry(ci, options, ask, askChoice) {
+  const fallbackKind = ci === "github" ? "github-packages" : "azure-artifacts";
+  const kind = await askChoice("Package registry", [
+    { name: "Azure Artifacts", value: "azure-artifacts" },
+    { name: "GitHub Packages", value: "github-packages" },
+    { name: "Public npm", value: "npm" }
+  ], fallbackKind, options.registry);
+  if (kind === "azure-artifacts") {
+    const organization = await ask("Azure DevOps organization", "my-org", options.organization);
+    const project = await ask("Azure DevOps project", "Automation", options.project);
+    const artifactsFeed = await ask("Azure Artifacts feed", "AUTO", options.feed);
+    return { kind, organization, project, artifactsFeed };
+  }
+  if (kind === "github-packages") {
+    const owner = await ask("GitHub owner (org or user)", "my-org", options.owner);
+    return { kind, owner };
+  }
+  return { kind: "npm" };
+}
+async function resolveInitialLib(provided, shouldAcceptDefaults) {
+  if (provided !== void 0) {
+    return provided === "" ? void 0 : toSlug(provided);
+  }
+  if (shouldAcceptDefaults) {
+    return "helpers";
+  }
+  const addLib = await (0, import_prompts2.confirm)({ message: "Add an initial internal library now?", default: true });
+  return addLib ? toSlug(await promptText("Library name", "helpers")) : void 0;
+}
+
+// src/commands/update.ts
+async function runUpdate() {
+  await runDoctor({ apply: true });
+}
+
+// src/util/exec.ts
+var import_node_child_process = require("child_process");
+function runShell(command, arguments_, cwd) {
+  const line = [command, ...arguments_].join(" ");
+  const result = (0, import_node_child_process.spawnSync)(line, { stdio: "inherit", shell: true, cwd });
+  return result.status ?? 1;
+}
+
+// src/commands/validate.ts
+async function runValidate(options) {
+  const repoRoot = process.cwd();
+  if (!isManagedRepo(repoRoot)) {
+    logger.error("No .monecromanci.json found here. Run `validate` from a MoNecromanCI monorepo root.");
+    return;
+  }
+  const arguments_ = ["nx", options.all ? "run-many" : "affected", "-t", "lint", "test", "build"];
+  logger.info(`Running: npx ${arguments_.join(" ")}`);
+  const status = runShell("npx", arguments_, repoRoot);
+  if (status === 0) {
+    logger.success("Validation passed.");
+    return;
+  }
+  logger.error(`Validation failed (exit ${status}).`);
+  process.exitCode = status;
+}
+
+// src/cli.ts
+function readVersion() {
+  try {
+    const package_ = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path9.join)(__dirname, "..", "package.json"), "utf8"));
+    return package_.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var program = new import_commander.Command();
+program.name("monecromanci").description("MoNecromanCI \u2014 summon, conjure, raise and validate NX monorepos").version(readVersion());
+program.command("new").alias("summon").argument("[name]", "monorepo name").option("-y, --yes", "non-interactive: accept provided values and defaults").option("--scope <scope>", "npm scope, e.g. @auto").option("--ci <provider>", "CI provider: azure | github | both").option("--registry <kind>", "registry: azure-artifacts | github-packages | npm").option("--owner <owner>", "GitHub owner for the github-packages registry").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--feed <feed>", "Azure Artifacts feed").option("--base <branch>", "default git branch").option("--lib <name>", "initial internal library name (empty string to skip)").description("Scaffold a brand-new canonical NX monorepo").action(async (name, options) => {
+  await runNew({
+    name,
+    yes: options.yes,
+    scope: options.scope,
+    ci: options.ci,
+    registry: options.registry,
+    owner: options.owner,
+    organization: options.org,
+    project: options.project,
+    feed: options.feed,
+    base: options.base,
+    lib: options.lib
+  });
+});
+program.command("add").alias("conjure").argument("[type]", "function-app | react-app | internal-lib | publishable-lib | cli-tool").argument("[name]", "project name").description("Add a new project to the current monorepo").action(async (type, name) => {
+  await runAdd({ type, name });
+});
+program.command("doctor").aliases(["fix", "raise"]).option("--fix", "apply fixes instead of only reporting").description("Detect and repair configuration drift in the current monorepo").action(async (options) => {
+  await runDoctor({ apply: options.fix ?? false });
+});
+program.command("update").alias("ascend").description("Re-sync tool-owned files to the latest templates and apply migrations").action(async () => {
+  await runUpdate();
+});
+program.command("validate").alias("ritual").option("--all", "run every project (nx run-many) instead of only affected").description("Run lint/test/build locally (nx affected) before pushing to CI").action(async (options) => {
+  await runValidate({ all: options.all ?? false });
+});
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map