@mnci/cli 4.30.0 → 4.32.0

package/dist/cli.js

@@ -44,6 +44,12 @@ var import_node_path = require("path");
 // src/nx-workspace/nx.client.ts
 var import_cross_spawn = __toESM(require("cross-spawn"));
 
+// src/terminal/json-output.client.ts
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+
 // src/terminal/logger.client.ts
 var logger = {
   info(message) {
@@ -2563,6 +2569,19 @@ function csharpConsoleProgram(identity) {
 Console.WriteLine(GreetUseCase.Greet("world").Message);
 `;
 }
+function csharpExampleTest(identity) {
+  return `using ${identity};
+
+public class GreetUseCaseTests
+{
+    [Fact]
+    public void GreetsAName()
+    {
+        Assert.Equal("Hello, world!", GreetUseCase.Greet("world").Message);
+    }
+}
+`;
+}
 
 // src/project-scaffolding/post-generation.use-case.ts
 var import_node_fs5 = require("fs");
@@ -2970,6 +2989,21 @@ function writeCsharpExample(absoluteRoot, identity, kind) {
     writeFileEnsured((0, import_node_path6.join)(absoluteRoot, "Program.cs"), csharpConsoleProgram(identity));
   }
 }
+function addCsharpTestProject(workspaceRoot, projectRoot, identity) {
+  const name = (0, import_node_path6.basename)(projectRoot);
+  const testRoot = `tests/${name}`;
+  scaffoldDotnetProject(workspaceRoot, testRoot, `${identity}.Tests`, "xunit");
+  (0, import_node_fs6.rmSync)((0, import_node_path6.join)(workspaceRoot, testRoot, "UnitTest1.cs"), { force: true });
+  writeFileEnsured((0, import_node_path6.join)(workspaceRoot, testRoot, "GreetUseCaseTests.cs"), csharpExampleTest(identity));
+  writeFileEnsured(
+    (0, import_node_path6.join)(workspaceRoot, testRoot, "project.json"),
+    toJson({ name: `${name}-tests`, tags: ["type:csharp-test"] })
+  );
+  const reference = (0, import_node_path6.join)(workspaceRoot, projectRoot, `${identity}.csproj`);
+  if (runShell("dotnet", ["add", (0, import_node_path6.join)(workspaceRoot, testRoot), "reference", reference], workspaceRoot) !== 0) {
+    throw new Error(`dotnet add reference failed for ${testRoot}`);
+  }
+}
 function csharpAppPackageTarget(tag, projectRoot, name) {
   const outDir = `dist/apps/${name}`;
   const zip = `dist/drop/${tag}-${name}.zip`;
@@ -2994,6 +3028,7 @@ function addCsharpApp(workspaceRoot, name, template = "console") {
   const projectRoot = `apps/${name}`;
   scaffoldDotnetProject(workspaceRoot, projectRoot, pascalCase(name), template);
   writeCsharpExample((0, import_node_path6.join)(workspaceRoot, projectRoot), pascalCase(name), template);
+  addCsharpTestProject(workspaceRoot, projectRoot, pascalCase(name));
   addProjectJsonTargets((0, import_node_path6.join)(workspaceRoot, projectRoot, "project.json"), {
     package: csharpAppPackageTarget("csharp-app", projectRoot, name),
     start: csharpAppStartTarget(projectRoot)
@@ -3118,6 +3153,7 @@ async function addCsharpLib(workspaceRoot, name, options, kindProvided) {
   const identity = `${pascalScope(scope)}.${pascalCase(name)}`;
   scaffoldDotnetProject(workspaceRoot, projectRoot, identity, "classlib");
   writeCsharpExample((0, import_node_path6.join)(workspaceRoot, projectRoot), identity, "classlib");
+  addCsharpTestProject(workspaceRoot, projectRoot, identity);
   addInitialVersion((0, import_node_path6.join)(workspaceRoot, projectRoot, `${identity}.csproj`));
   writeCsharpVersionActions(workspaceRoot);
   addProjectJsonReleaseVersionActions((0, import_node_path6.join)(workspaceRoot, projectRoot, "project.json"));
@@ -3135,6 +3171,7 @@ function addCsharpInternalLib(workspaceRoot, name) {
   const identity = pascalCase(name);
   scaffoldDotnetProject(workspaceRoot, projectRoot, identity, "classlib");
   writeCsharpExample((0, import_node_path6.join)(workspaceRoot, projectRoot), identity, "classlib");
+  addCsharpTestProject(workspaceRoot, projectRoot, identity);
   registerProjectCommands(workspaceRoot, name, { build: false });
   logger.step(
     `Reference it from a consumer with: dotnet add <consumer>.csproj reference ${projectRoot}/${identity}.csproj`
@@ -3214,6 +3251,7 @@ function addCsharpFunctionApp(workspaceRoot, name) {
   if (runShell("dotnet", ["restore", projectRoot], workspaceRoot) !== 0) {
     throw new Error(`dotnet restore failed for ${projectRoot}`);
   }
+  addCsharpTestProject(workspaceRoot, projectRoot, identity);
   addProjectJsonTargets((0, import_node_path6.join)(absoluteRoot, "project.json"), {
     package: csharpAppPackageTarget("csharp-function-app", projectRoot, name),
     start: csharpFunctionAppStartTarget(projectRoot)
@@ -7023,6 +7061,45 @@ function readWorkspaceStack(workspaceRoot) {
   };
 }
 
+// src/project-scaffolding/project-kind-catalog.config.ts
+var PROJECT_KIND_CATALOG = [
+  { kind: "react-app", language: "typescript", label: "React app", description: "A Vite React app, built per environment", flags: [], requiredFlags: [] },
+  { kind: "react-lib", language: "typescript", label: "React library", description: "A publishable React component library", flags: ["scope", "empty"], requiredFlags: [] },
+  { kind: "react-internal-lib", language: "typescript", label: "React internal library", description: "A private React library for apps in this workspace", flags: ["empty"], requiredFlags: [] },
+  { kind: "node-app", language: "typescript", label: "Node app", description: "A Node service, with Express, Fastify, Koa or Nest if you choose one", flags: ["framework"], requiredFlags: [] },
+  { kind: "node-function-app", language: "typescript", label: "Node function app", description: "An Azure Functions (v4) app in TypeScript", flags: ["empty"], requiredFlags: [] },
+  { kind: "npm-lib", language: "typescript", label: "npm library", description: "A library published to npm, bundled with Rollup", flags: ["scope", "empty"], requiredFlags: [] },
+  { kind: "internal-lib", language: "typescript", label: "Internal library", description: "A private TypeScript library for apps in this workspace", flags: ["empty"], requiredFlags: [] },
+  { kind: "vscode-extension", language: "typescript", label: "VS Code extension", description: "A bundled Marketplace extension, optionally shipping a Go sidecar", flags: ["publisher", "sidecar"], requiredFlags: [] },
+  { kind: "python-app", language: "python", label: "Python app", description: "A pip-native Python application (Ruff, pytest)", flags: [], requiredFlags: [] },
+  { kind: "python-function-app", language: "python", label: "Python function app", description: "An Azure Functions (v2 model) app in Python", flags: [], requiredFlags: [] },
+  { kind: "python-lib", language: "python", label: "Python library", description: "A Python package published with twine", flags: [], requiredFlags: [] },
+  { kind: "python-internal-lib", language: "python", label: "Python internal library", description: "A private Python library, vendored into the apps that use it", flags: [], requiredFlags: [] },
+  { kind: "python-vendor", language: "python", label: "Vendor a Python library", description: "Copy an internal Python library into a consumer so it can be packaged", flags: ["lib"], requiredFlags: ["lib"] },
+  { kind: "go-app", language: "go", label: "Go app", description: "A Go executable with one static binary per platform", flags: ["release", "cgo", "web"], requiredFlags: [] },
+  { kind: "go-function-app", language: "go", label: "Go function app", description: "A Go Azure Functions custom handler", flags: [], requiredFlags: [] },
+  { kind: "go-lib", language: "go", label: "Go library", description: "A Go module other repositories can go get", flags: [], requiredFlags: [] },
+  { kind: "go-internal-lib", language: "go", label: "Go internal library", description: "A private Go module for apps in this workspace", flags: [], requiredFlags: [] },
+  { kind: "flutter-app", language: "flutter", label: "Flutter app", description: "A Flutter app built for the web", flags: [], requiredFlags: [] },
+  { kind: "flutter-lib", language: "flutter", label: "Flutter library", description: "A Dart package released by git tag", flags: [], requiredFlags: [] },
+  { kind: "flutter-internal-lib", language: "flutter", label: "Flutter internal library", description: "A private Dart package for apps in this workspace", flags: [], requiredFlags: [] },
+  { kind: "csharp-app", language: "csharp", label: "C# app", description: "A .NET console, web API or worker app", flags: [], requiredFlags: [] },
+  { kind: "csharp-function-app", language: "csharp", label: "C# function app", description: "An Azure Functions isolated-worker app", flags: [], requiredFlags: [] },
+  { kind: "csharp-lib", language: "csharp", label: "C# library", description: "A NuGet package", flags: ["scope"], requiredFlags: [] },
+  { kind: "csharp-internal-lib", language: "csharp", label: "C# internal library", description: "A private .NET library for apps in this workspace", flags: [], requiredFlags: [] }
+];
+
+// src/project-scaffolding/list-project-kinds.use-case.ts
+function runKinds(options) {
+  if (options.json === true) {
+    printJson(PROJECT_KIND_CATALOG);
+    return;
+  }
+  for (const entry of PROJECT_KIND_CATALOG) {
+    logger.info(`${entry.kind.padEnd(22)} ${entry.description}`);
+  }
+}
+
 // src/workspace-diagnostics/check-invariants.use-case.ts
 var import_node_child_process = require("child_process");
 var import_node_fs19 = require("fs");
@@ -7302,10 +7379,12 @@ function checkOneTargetsFiles(workspaceRoot, source, targetName, target) {
   });
 }
 function checkSync(workspaceRoot) {
+  const result = runCapture("npx", ["nx", "sync:check"], workspaceRoot);
   return {
     check: "TypeScript project references synced",
-    ok: runShell("npx", ["nx", "sync:check"], workspaceRoot) === 0,
-    detail: "nx sync:check failed \u2014 a stale project reference was never committed",
+    ok: result.status === 0,
+    detail: `nx sync:check failed \u2014 a stale project reference was never committed${result.stdout.trim() ? `
+${result.stdout.trim()}` : ""}`,
     remedy: "run `npx nx sync` and commit the result"
   };
 }
@@ -7470,9 +7549,16 @@ function collectFindings(workspaceRoot) {
     ...checkNativeApps(workspaceRoot)
   ].filter((finding) => finding !== void 0);
 }
-function runDoctor(workspaceRoot) {
+function runDoctor(workspaceRoot, options = {}) {
   const findings = collectFindings(workspaceRoot);
   const failed = findings.filter((finding) => !finding.ok);
+  if (options.json === true) {
+    printJson({ findings, passed: findings.length - failed.length, failed: failed.length });
+    if (failed.length > 0) {
+      process.exitCode = 1;
+    }
+    return;
+  }
   for (const finding of findings) {
     if (finding.ok) {
       logger.success(finding.check);
@@ -7491,9 +7577,204 @@ function runDoctor(workspaceRoot) {
   process.exitCode = 1;
 }
 
-// src/workspace-creation/adopt-directory.use-case.ts
-var import_node_fs20 = require("fs");
+// src/command-catalog/command-groups.config.ts
+var COMMAND_GROUPS = {
+  new: "workspace",
+  upgrade: "workspace",
+  doctor: "workspace",
+  add: "projects",
+  install: "dependencies",
+  sync: "dependencies",
+  up: "dependencies",
+  ci: "pipeline",
+  commands: "inspect",
+  kinds: "inspect",
+  projects: "inspect",
+  info: "inspect"
+};
+
+// src/command-catalog/describe-commands.algorithm.ts
+function describeOption(option) {
+  const isScalar = ["string", "number", "boolean"].includes(typeof option.defaultValue);
+  return {
+    name: option.name(),
+    flags: option.flags,
+    short: option.short,
+    description: option.description,
+    takesValue: option.required ? "required" : option.optional ? "optional" : "none",
+    variadic: option.variadic,
+    // A repeatable flag is declared with a list as its default, which its collector appends to.
+    repeatable: Array.isArray(option.defaultValue),
+    negated: option.negate,
+    choices: option.argChoices,
+    defaultValue: isScalar ? option.defaultValue : void 0
+  };
+}
+function describeCommands(program) {
+  return program.commands.filter((command) => command.name() !== "help").map((command) => {
+    const group = COMMAND_GROUPS[command.name()];
+    if (group === void 0) {
+      throw new Error(`Command '${command.name()}' has no group in COMMAND_GROUPS (command-catalog/command-groups.config.ts).`);
+    }
+    const args = command.registeredArguments.map((argument) => ({
+      name: argument.name(),
+      description: argument.description,
+      required: argument.required,
+      variadic: argument.variadic,
+      choices: argument.argChoices
+    }));
+    return {
+      name: command.name(),
+      aliases: command.aliases(),
+      group,
+      description: command.description(),
+      arguments: args,
+      options: command.options.map((option) => describeOption(option))
+    };
+  });
+}
+
+// src/command-catalog/list-commands.use-case.ts
+function runCommands(program, options) {
+  const commands = describeCommands(program);
+  if (options.json === true) {
+    printJson(commands);
+    return;
+  }
+  for (const command of commands) {
+    logger.info(`${command.name.padEnd(10)} ${command.description}`);
+  }
+}
+
+// src/workspace-info/list-projects.use-case.ts
 var import_node_path27 = require("path");
+var TYPE_TAG_PREFIX = "type:";
+function listProjects(workspaceRoot) {
+  return locateProjects(workspaceRoot).map((location) => {
+    const projectJsonPath = (0, import_node_path27.join)(workspaceRoot, location.dir, "project.json");
+    const project = fileExists(projectJsonPath) ? readJson(projectJsonPath) : {};
+    const typeTag = (project.tags ?? []).find((tag) => tag.startsWith(TYPE_TAG_PREFIX));
+    return {
+      name: location.name,
+      dir: location.dir,
+      ecosystem: location.ecosystem,
+      kind: typeTag?.slice(TYPE_TAG_PREFIX.length),
+      targets: Object.keys(project.targets ?? {})
+    };
+  }).toSorted((a, b) => a.dir.localeCompare(b.dir));
+}
+function runProjects(workspaceRoot, options) {
+  if (!fileExists((0, import_node_path27.join)(workspaceRoot, "nx.json"))) {
+    throw new Error("No nx.json found here. Run `projects` from the workspace root.");
+  }
+  const projects = listProjects(workspaceRoot);
+  if (options.json === true) {
+    printJson(projects);
+    return;
+  }
+  for (const project of projects) {
+    logger.info(`${project.dir.padEnd(32)} ${project.ecosystem}${project.kind ? `  ${project.kind}` : ""}`);
+  }
+}
+
+// src/workspace-info/read-workspace-info.use-case.ts
+var import_node_path29 = require("path");
+
+// src/cli-version/check-for-update.use-case.ts
+var import_node_fs20 = require("fs");
+var import_node_path28 = require("path");
+var import_cross_spawn2 = __toESM(require("cross-spawn"));
+var PACKAGE_NAME = "@mnci/cli";
+var REGISTRY_TIMEOUT_MS = 2e3;
+function checkForUpdate(currentVersion2) {
+  try {
+    if (!process.stdout.isTTY) {
+      return;
+    }
+    setImmediate(() => {
+      try {
+        reportIfOutdated(currentVersion2);
+      } catch {
+      }
+    });
+  } catch {
+  }
+}
+function fetchLatestVersion() {
+  const result = import_cross_spawn2.default.sync("npm", ["view", PACKAGE_NAME, "version"], {
+    encoding: "utf8",
+    timeout: REGISTRY_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.error || result.status !== 0) {
+    return void 0;
+  }
+  return (result.stdout ?? "").trim() || void 0;
+}
+function reportIfOutdated(currentVersion2) {
+  const latestVersion = fetchLatestVersion();
+  if (!latestVersion || !isNewerVersion(latestVersion, currentVersion2)) {
+    return;
+  }
+  logger.info("");
+  logger.info(`A new version of ${PACKAGE_NAME} is available: ${latestVersion}`);
+  logger.info(`  Current version: ${currentVersion2}`);
+  logger.info(`  Update with: npm install -g ${PACKAGE_NAME}@latest`);
+  logger.info("");
+}
+function isNewerVersion(candidate, current) {
+  const candidateParts = releaseTriple(candidate);
+  const currentParts = releaseTriple(current);
+  if (!candidateParts || !currentParts) {
+    return false;
+  }
+  for (const [index, candidatePart] of candidateParts.entries()) {
+    if (candidatePart !== currentParts[index]) {
+      return candidatePart > currentParts[index];
+    }
+  }
+  return false;
+}
+function releaseTriple(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : void 0;
+}
+function readCliVersion(packageDirectory) {
+  try {
+    const manifestPath = (0, import_node_path28.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs20.readFileSync)(manifestPath, "utf8"));
+    return manifest.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// src/workspace-info/read-workspace-info.use-case.ts
+function readWorkspaceInfo(workspaceRoot, cliVersion) {
+  const latest = fetchLatestVersion() ?? null;
+  const isWorkspace = fileExists((0, import_node_path29.join)(workspaceRoot, "nx.json"));
+  return {
+    cli: {
+      version: cliVersion,
+      latest,
+      updateAvailable: latest !== null && isNewerVersion(latest, cliVersion)
+    },
+    workspace: isWorkspace ? { root: workspaceRoot, config: { ...readMnciConfig(workspaceRoot) } } : null
+  };
+}
+function runInfo(workspaceRoot, cliVersion, options) {
+  const info = readWorkspaceInfo(workspaceRoot, cliVersion);
+  if (options.json === true) {
+    printJson(info);
+    return;
+  }
+  logger.info(`mnci ${info.cli.version}${info.cli.updateAvailable ? ` (${info.cli.latest} is available)` : ""}`);
+  logger.info(info.workspace ? `workspace: ${info.workspace.root}` : "not inside a workspace");
+}
+
+// src/workspace-creation/adopt-directory.use-case.ts
+var import_node_fs21 = require("fs");
+var import_node_path30 = require("path");
 var NEVER_COPIED = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var AGENT_AND_CI_ENTRIES = [
   "AGENTS.md",
@@ -7524,13 +7805,13 @@ var PREFLIGHT_BLOCKERS = [
   "packages"
 ];
 function assertAdoptableDirectory(target) {
-  if (!(0, import_node_fs20.existsSync)(target)) {
+  if (!(0, import_node_fs21.existsSync)(target)) {
     throw new Error(`--into '${target}' does not exist. Create or clone it first.`);
   }
-  if (!(0, import_node_fs20.statSync)(target).isDirectory()) {
+  if (!(0, import_node_fs21.statSync)(target).isDirectory()) {
     throw new Error(`--into '${target}' is not a directory.`);
   }
-  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs20.existsSync)((0, import_node_path27.join)(target, entry)));
+  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs21.existsSync)((0, import_node_path30.join)(target, entry)));
   if (blockers.length > 0) {
     throw new Error(
       `--into '${target}' already holds ${blockers.join(", ")}, so it is a project already. Use \`mnci upgrade\` to re-apply the overlay to an existing workspace, or point --into at an empty checkout.`
@@ -7538,15 +7819,15 @@ function assertAdoptableDirectory(target) {
   }
 }
 function mergeGitignore(generatedFile, targetFile) {
-  const existing = (0, import_node_fs20.readFileSync)(targetFile, "utf8");
+  const existing = (0, import_node_fs21.readFileSync)(targetFile, "utf8");
   const present = new Set(existing.split("\n").map((line) => line.trim()));
-  const additions = (0, import_node_fs20.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
+  const additions = (0, import_node_fs21.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
     const trimmed = line.trim();
     return trimmed !== "" && !trimmed.startsWith("#") && !present.has(trimmed);
   });
   if (additions.length === 0) return false;
   const separator = existing.endsWith("\n") ? "" : "\n";
-  (0, import_node_fs20.writeFileSync)(
+  (0, import_node_fs21.writeFileSync)(
     targetFile,
     `${existing}${separator}
 # Added by mnci (Nx workspace)
@@ -7556,9 +7837,9 @@ ${additions.join("\n")}
   return true;
 }
 function adoptGeneratedWorkspace(generatedRoot, target) {
-  const entries = (0, import_node_fs20.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
+  const entries = (0, import_node_fs21.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
   const collisions = entries.filter(
-    (entry) => (0, import_node_fs20.existsSync)((0, import_node_path27.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
+    (entry) => (0, import_node_fs21.existsSync)((0, import_node_path30.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
   );
   if (collisions.length > 0) {
     throw new Error(
@@ -7567,28 +7848,28 @@ function adoptGeneratedWorkspace(generatedRoot, target) {
   }
   const result = { copied: [], kept: [], mergedGitignore: false };
   for (const entry of entries) {
-    const from = (0, import_node_path27.join)(generatedRoot, entry);
-    const to = (0, import_node_path27.join)(target, entry);
-    if (entry === ".gitignore" && (0, import_node_fs20.existsSync)(to)) {
+    const from = (0, import_node_path30.join)(generatedRoot, entry);
+    const to = (0, import_node_path30.join)(target, entry);
+    if (entry === ".gitignore" && (0, import_node_fs21.existsSync)(to)) {
       result.mergedGitignore = mergeGitignore(from, to);
       result.kept.push(entry);
       continue;
     }
-    if ((0, import_node_fs20.existsSync)(to)) {
+    if ((0, import_node_fs21.existsSync)(to)) {
       result.kept.push(entry);
       continue;
     }
-    (0, import_node_fs20.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs21.cpSync)(from, to, { recursive: true });
     result.copied.push(entry);
   }
-  (0, import_node_fs20.rmSync)(generatedRoot, { recursive: true, force: true });
+  (0, import_node_fs21.rmSync)(generatedRoot, { recursive: true, force: true });
   return result;
 }
 
 // src/workspace-creation/create-workspace.use-case.ts
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_os = require("os");
-var import_node_path28 = require("path");
+var import_node_path31 = require("path");
 function nxCloudProviderValue(ci) {
   return ci === "azure" ? "azure" : "github";
 }
@@ -7631,9 +7912,9 @@ async function resolveRegistry(options) {
   return await promptRegistry();
 }
 async function runNew(name, options) {
-  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path28.resolve)(process.cwd(), options.into);
+  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path31.resolve)(process.cwd(), options.into);
   if (adoptTarget !== void 0) assertAdoptableDirectory(adoptTarget);
-  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path28.basename)(adoptTarget));
+  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path31.basename)(adoptTarget));
   assertValidProjectName(workspaceName, "Workspace name");
   const scope = options.scope ?? (options.yes ? `@${workspaceName}` : await promptText("npm scope for publishable packages", `@${workspaceName}`));
   const registry = await resolveRegistry(options);
@@ -7646,8 +7927,8 @@ async function runNew(name, options) {
   const npmAuth = resolveNpmAuth(options.npmAuth, registry, ci);
   const stack = await resolveStack(options);
   const nxCloud = options.nxCloud ?? (options.yes ? false : await promptNxCloud());
-  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs21.mkdtempSync)((0, import_node_path28.join)((0, import_node_os.tmpdir)(), "mnci-new-"));
-  let workspaceRoot = (0, import_node_path28.join)(stagingParent, workspaceName);
+  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs22.mkdtempSync)((0, import_node_path31.join)((0, import_node_os.tmpdir)(), "mnci-new-"));
+  let workspaceRoot = (0, import_node_path31.join)(stagingParent, workspaceName);
   try {
     logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
     runNpx(
@@ -7670,7 +7951,7 @@ async function runNew(name, options) {
       workspaceRoot = adoptTarget;
     }
   } finally {
-    if (adoptTarget !== void 0) (0, import_node_fs21.rmSync)(stagingParent, { recursive: true, force: true });
+    if (adoptTarget !== void 0) (0, import_node_fs22.rmSync)(stagingParent, { recursive: true, force: true });
   }
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
@@ -7680,8 +7961,8 @@ async function runNew(name, options) {
     { workspaceName, scope, registry, agent, variableGroup, ci, stack, ...npmAuth && { npmAuth } },
     logger.detail
   );
-  (0, import_node_fs21.rmSync)((0, import_node_path28.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs21.rmSync)((0, import_node_path28.join)(workspaceRoot, "package-lock.json"), { force: true });
+  (0, import_node_fs22.rmSync)((0, import_node_path31.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs22.rmSync)((0, import_node_path31.join)(workspaceRoot, "package-lock.json"), { force: true });
   logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",
@@ -7719,12 +8000,12 @@ function projectKindHintLines(kinds = PROJECT_KINDS) {
 }
 
 // src/workspace-creation/interactive-wizard.use-case.ts
-var import_node_path30 = require("path");
+var import_node_path33 = require("path");
 var import_prompts4 = require("@inquirer/prompts");
 
 // src/workspace-upgrade/upgrade-workspace.use-case.ts
-var import_node_fs22 = require("fs");
-var import_node_path29 = require("path");
+var import_node_fs23 = require("fs");
+var import_node_path32 = require("path");
 function resolveRegistry2(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
     const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
@@ -7753,7 +8034,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     return persisted.workspaceName;
   }
   try {
-    const existing = (0, import_node_fs22.readdirSync)(workspaceRoot).find(
+    const existing = (0, import_node_fs23.readdirSync)(workspaceRoot).find(
       (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
     );
     if (existing) {
@@ -7761,11 +8042,11 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     }
   } catch {
   }
-  return (0, import_node_path29.basename)(workspaceRoot);
+  return (0, import_node_path32.basename)(workspaceRoot);
 }
 function detectNpmAuth(workspaceRoot) {
   try {
-    return (0, import_node_fs22.readFileSync)((0, import_node_path29.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
+    return (0, import_node_fs23.readFileSync)((0, import_node_path32.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
   } catch {
     return void 0;
   }
@@ -7812,7 +8093,7 @@ function resolveOverlayOptions(workspaceRoot, options, persisted) {
   };
 }
 function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path29.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path32.join)(workspaceRoot, "nx.json"))) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 this does not look like an Nx workspace. Run 'mnci upgrade' from the workspace root.`
     );
@@ -7877,7 +8158,7 @@ function runUpgrade(workspaceRoot, options) {
 
 // src/workspace-creation/interactive-wizard.use-case.ts
 async function runInteractive() {
-  const inWorkspace = fileExists((0, import_node_path30.join)(process.cwd(), "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path33.join)(process.cwd(), "nx.json"));
   const choiceNew = { name: "Create a new monorepo", value: "new" };
   const choiceAdd = { name: "Add a project to this workspace", value: "add" };
   const choiceUpgrade = {
@@ -7897,72 +8178,6 @@ async function runInteractive() {
   }
 }
 
-// src/cli-version/check-for-update.use-case.ts
-var import_node_fs23 = require("fs");
-var import_node_path31 = require("path");
-var import_cross_spawn2 = __toESM(require("cross-spawn"));
-var PACKAGE_NAME = "@mnci/cli";
-var REGISTRY_TIMEOUT_MS = 2e3;
-function checkForUpdate(currentVersion2) {
-  try {
-    if (!process.stdout.isTTY) {
-      return;
-    }
-    setImmediate(() => {
-      try {
-        reportIfOutdated(currentVersion2);
-      } catch {
-      }
-    });
-  } catch {
-  }
-}
-function reportIfOutdated(currentVersion2) {
-  const result = import_cross_spawn2.default.sync("npm", ["view", PACKAGE_NAME, "version"], {
-    encoding: "utf8",
-    timeout: REGISTRY_TIMEOUT_MS,
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  if (result.error || result.status !== 0) {
-    return;
-  }
-  const latestVersion = (result.stdout ?? "").trim();
-  if (!latestVersion || !isNewerVersion(latestVersion, currentVersion2)) {
-    return;
-  }
-  logger.info("");
-  logger.info(`A new version of ${PACKAGE_NAME} is available: ${latestVersion}`);
-  logger.info(`  Current version: ${currentVersion2}`);
-  logger.info(`  Update with: npm install -g ${PACKAGE_NAME}@latest`);
-  logger.info("");
-}
-function isNewerVersion(candidate, current) {
-  const candidateParts = releaseTriple(candidate);
-  const currentParts = releaseTriple(current);
-  if (!candidateParts || !currentParts) {
-    return false;
-  }
-  for (const [index, candidatePart] of candidateParts.entries()) {
-    if (candidatePart !== currentParts[index]) {
-      return candidatePart > currentParts[index];
-    }
-  }
-  return false;
-}
-function releaseTriple(version) {
-  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
-  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : void 0;
-}
-function readCliVersion(packageDirectory) {
-  try {
-    const manifestPath = (0, import_node_path31.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs23.readFileSync)(manifestPath, "utf8"));
-    return manifest.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
 // src/main.ts
 function buildProgram(cliVersion) {
   const program = new import_commander.Command();
@@ -7992,8 +8207,8 @@ function buildProgram(cliVersion) {
   });
   program.command("doctor").description(
     "Check this workspace against the invariants mnci maintains (one ESLint config, no stray .prettierrc, the eslint plugin registered, the resolved eslint major, .npmrc vs the recorded registry, versionActions overrides, nx sync) \u2014 read-only; exits non-zero if anything failed"
-  ).action(() => {
-    runDoctor(process.cwd());
+  ).option("--json", "print the findings as one JSON document, each with its remedy").action((options) => {
+    runDoctor(process.cwd(), options);
   });
   program.command("ci").addArgument(new import_commander.Argument("<phase>", "which phase of the pipeline to run").choices(CI_PHASES)).description(
     "Run a phase of the CI pipeline here, the same way CI runs it: `verify` is the sync check and then every project (or, in a pull request, the affected ones) through lint, typecheck, test and build. Exits non-zero when it fails"
@@ -8012,12 +8227,16 @@ function buildProgram(cliVersion) {
   });
   program.command("install").alias("i").argument("[packages...]", "packages to add (a bare name or a pinned spec); omit to install only").description(
     "Add a dependency to a specific project using its own toolchain (npm/pip/pub/nuget/go), or \u2014 with no package \u2014 install everything. Each project owns its dependencies, so a package needs a target: 'mnci i -w <project> <package>'"
-  ).option("-w, --workspace <project...>", "target project, by directory (apps/foo) or basename (foo); repeatable").option("-D, --save-dev", "add as a development dependency, where the ecosystem distinguishes one").action((packages, options) => {
+  ).option(
+    "-w, --workspace <project>",
+    "target project, by directory (apps/foo) or basename (foo); give the flag again for each project",
+    (project, projects) => [...projects, project],
+    []
+  ).option("-D, --save-dev", "add as a development dependency, where the ecosystem distinguishes one").action((packages, options) => {
     runInstall(process.cwd(), packages, options);
   });
-  program.command("add").addArgument(new import_commander.Argument("[kind]", "project kind").choices(PROJECT_KINDS)).argument("[name]", "project name").description("Add a project by delegating to the matching Nx plugin generator").option("--scope <scope>", "npm scope for a publishable lib (defaults to @<workspace name>)").option(
-    "--framework <framework>",
-    "node-app only: express | fastify | koa | nest | none (default: none)"
+  program.command("add").addArgument(new import_commander.Argument("[kind]", "project kind").choices(PROJECT_KINDS)).argument("[name]", "project name").description("Add a project by delegating to the matching Nx plugin generator").option("--scope <scope>", "npm scope for a publishable lib (defaults to @<workspace name>)").addOption(
+    new import_commander.Option("--framework <framework>", "node-app only: the web framework (default: none)").choices(["express", "fastify", "koa", "nest", "none"])
   ).option(
     "--empty",
     "npm-lib, internal-lib, react-lib, react-internal-lib, node-function-app: scaffold the slice skeleton only, with no sample code or spec"
@@ -8044,6 +8263,18 @@ function buildProgram(cliVersion) {
       await runAdd(kind, name, options);
     }
   );
+  program.command("commands").description("List every command with what it does and how to call it (--json is what an editor builds its menu from)").option("--json", "print the catalog as one JSON document").action((options) => {
+    runCommands(program, options);
+  });
+  program.command("kinds").description("List every project kind that `add` accepts, with its language, a description and the flags that apply").option("--json", "print the kinds as one JSON document").action((options) => {
+    runKinds(options);
+  });
+  program.command("projects").description("List this workspace's projects: directory, ecosystem, the kind mnci recorded and its explicit targets").option("--json", "print the projects as one JSON document").action((options) => {
+    runProjects(process.cwd(), options);
+  });
+  program.command("info").description("Show the installed mnci version, the newest published one, and this workspace's recorded settings").option("--json", "print the report as one JSON document").action((options) => {
+    runInfo(process.cwd(), cliVersion, options);
+  });
   program.action(async () => {
     await runInteractive();
   });