@mnci/cli 4.17.6 → 4.19.0

package/dist/cli.js

@@ -2342,7 +2342,7 @@ function runCiPhase(phase, workspaceRoot, dependencies = {}) {
 }
 
 // src/project-scaffolding/add-project.use-case.ts
-var import_node_path23 = require("path");
+var import_node_path24 = require("path");
 var import_prompts3 = require("@inquirer/prompts");
 
 // src/project-name/project-name.validator.ts
@@ -2971,13 +2971,47 @@ function isNxGoPluginRegistered(workspaceRoot) {
   }
   return (readJson(nxJsonPath).plugins ?? []).some((entry) => (typeof entry === "string" ? entry : entry.plugin) === NX_GO_PLUGIN);
 }
+function modulePrefixFromRemoteUrl(url) {
+  const trimmed = url.trim();
+  const scpLike = /^[^@/]+@([^:]+):(.+)$/.exec(trimmed);
+  const withScheme = /^[a-z][\w+.-]*:\/\/(?:[^@/]+@)?(.+)$/i.exec(trimmed);
+  let path;
+  if (scpLike) {
+    path = `${scpLike[1]}/${scpLike[2]}`;
+  } else if (withScheme) {
+    path = withScheme[1];
+  }
+  if (path === void 0) {
+    return void 0;
+  }
+  const cleaned = path.replace(/\.git$/, "").replace(/\/+$/, "");
+  return cleaned === "" ? void 0 : cleaned;
+}
+function goModulePrefix(workspaceRoot) {
+  const result = runCapture("git", ["remote", "get-url", "origin"], workspaceRoot);
+  return result.status === 0 ? modulePrefixFromRemoteUrl(result.stdout) : void 0;
+}
 function registerNxGoPlugin(workspaceRoot) {
   const nxJsonPath = (0, import_node_path7.join)(workspaceRoot, "nx.json");
-  if (!fileExists(nxJsonPath) || isNxGoPluginRegistered(workspaceRoot)) {
+  if (!fileExists(nxJsonPath)) {
     return false;
   }
+  const modulePrefix = goModulePrefix(workspaceRoot);
+  const entry = modulePrefix === void 0 ? NX_GO_PLUGIN : { plugin: NX_GO_PLUGIN, options: { modulePrefix } };
   const nxJson = readJson(nxJsonPath);
-  writeFileEnsured(nxJsonPath, toJson({ ...nxJson, plugins: [...nxJson.plugins ?? [], NX_GO_PLUGIN] }));
+  const plugins = [...nxJson.plugins ?? []];
+  const index = plugins.findIndex((plugin) => (typeof plugin === "string" ? plugin : plugin.plugin) === NX_GO_PLUGIN);
+  if (index === -1) {
+    plugins.push(entry);
+  } else {
+    const current = plugins[index];
+    const currentPrefix = typeof current === "string" ? void 0 : current.options?.modulePrefix;
+    if (modulePrefix === void 0 || currentPrefix === modulePrefix) {
+      return false;
+    }
+    plugins[index] = entry;
+  }
+  writeFileEnsured(nxJsonPath, toJson({ ...nxJson, plugins }));
   return true;
 }
 
@@ -3322,21 +3356,36 @@ function ensureNxGoPlugin(workspaceRoot) {
   }
 }
 function ensureGoModule(workspaceRoot) {
-  if (fileExists((0, import_node_path10.join)(workspaceRoot, "go.mod"))) {
+  if (fileExists((0, import_node_path10.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path10.join)(workspaceRoot, "go.mod"))) {
     return;
   }
-  logger.step("Bootstrapping the workspace Go module (single root go.mod)");
+  logger.step("Bootstrapping the Go workspace (go.work, one module per project)");
   runNx(["g", "@nx-go/nx-go:init", "--no-interactive"], workspaceRoot);
-  runNx(["g", "@nx-go/nx-go:convert-to-one-mod", "--no-interactive"], workspaceRoot);
 }
-function goModulePath(workspaceRoot) {
+function readGoModModule(goModPath) {
   try {
-    const contents = (0, import_node_fs9.readFileSync)((0, import_node_path10.join)(workspaceRoot, "go.mod"), "utf8");
-    return /^module\s+(\S+)/m.exec(contents)?.[1];
+    return /^module\s+(\S+)/m.exec((0, import_node_fs9.readFileSync)(goModPath, "utf8"))?.[1];
   } catch {
     return void 0;
   }
 }
+function goModulePathFor(workspaceRoot, projectDir) {
+  const projectModule = readGoModModule((0, import_node_path10.join)(workspaceRoot, projectDir, "go.mod"));
+  if (projectModule !== void 0) {
+    return projectModule;
+  }
+  const rootModule = readGoModModule((0, import_node_path10.join)(workspaceRoot, "go.mod"));
+  return rootModule === void 0 ? void 0 : `${rootModule}/${projectDir}`;
+}
+function setGoModulePath(workspaceRoot, projectDir) {
+  const prefix = goModulePrefix(workspaceRoot);
+  const goModPath = (0, import_node_path10.join)(workspaceRoot, projectDir, "go.mod");
+  if (prefix === void 0 || !fileExists(goModPath)) {
+    return;
+  }
+  const rewritten = (0, import_node_fs9.readFileSync)(goModPath, "utf8").replace(/^module\s+\S+/m, () => `module ${prefix}/${projectDir}`);
+  writeFileEnsured(goModPath, rewritten);
+}
 function goTestTarget() {
   return { executor: "@nx-go/nx-go:test" };
 }
@@ -3533,6 +3582,7 @@ function addGoApp(workspaceRoot, name, options = {}) {
     ],
     workspaceRoot
   );
+  setGoModulePath(workspaceRoot, `apps/${name}`);
   addProjectJsonTargets((0, import_node_path10.join)(workspaceRoot, "apps", name, "project.json"), {
     build: goBuildTarget(name),
     test: goTestTarget(),
@@ -3571,6 +3621,7 @@ function addGoFunctionApp(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  setGoModulePath(workspaceRoot, `apps/${name}`);
   addProjectJsonTargets((0, import_node_path10.join)(workspaceRoot, "apps", name, "project.json"), {
     "build": goBuildTarget(name),
     "test": goTestTarget(),
@@ -3594,15 +3645,16 @@ function addGoLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  setGoModulePath(workspaceRoot, `packages/${name}`);
   addProjectJsonTargets((0, import_node_path10.join)(workspaceRoot, "packages", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
   const slice = reshapeGoLibraryScaffold((0, import_node_path10.join)(workspaceRoot, "packages", name), name);
   registerProjectCommands(workspaceRoot, name, { build: false });
-  const module2 = goModulePath(workspaceRoot);
+  const module2 = goModulePathFor(workspaceRoot, `packages/${name}`);
   if (module2) {
-    logger.step(`Import its starter slice as ${module2}/packages/${name}/${slice}`);
+    logger.step(`Import its starter slice as ${module2}/${slice}`);
   }
 }
 function addGoInternalLib(workspaceRoot, name) {
@@ -3618,15 +3670,16 @@ function addGoInternalLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  setGoModulePath(workspaceRoot, `libs/${name}`);
   addProjectJsonTargets((0, import_node_path10.join)(workspaceRoot, "libs", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
   const slice = reshapeGoLibraryScaffold((0, import_node_path10.join)(workspaceRoot, "libs", name), name);
   registerProjectCommands(workspaceRoot, name, { build: false });
-  const module2 = goModulePath(workspaceRoot);
+  const module2 = goModulePathFor(workspaceRoot, `libs/${name}`);
   if (module2) {
-    logger.step(`Import its starter slice as ${module2}/libs/${name}/${slice}`);
+    logger.step(`Import its starter slice as ${module2}/${slice}`);
   }
 }
 
@@ -4946,7 +4999,8 @@ function addVscodeExtension(workspaceRoot, name, stack, options = {}) {
   refreshLockFile(workspaceRoot, name);
 }
 
-// src/dependency-management/sync-dependencies.use-case.ts
+// src/dependency-management/install-dependencies.use-case.ts
+var import_node_fs17 = require("fs");
 var import_node_path21 = require("path");
 
 // src/dependency-management/manifest.repository.ts
@@ -5277,6 +5331,27 @@ function collectInventory(workspaceRoot, ecosystems = ECOSYSTEMS) {
   }
   return inventory;
 }
+var PROJECT_GLOBS = {
+  ...MANIFEST_GLOBS,
+  go: ["apps/*/go.mod", "libs/*/go.mod", "packages/*/go.mod"]
+};
+function locateProjects(workspaceRoot) {
+  const locations = [];
+  for (const ecosystem of ECOSYSTEMS) {
+    const relativePaths = (0, import_node_fs16.globSync)(PROJECT_GLOBS[ecosystem], { cwd: workspaceRoot });
+    for (const relativePath of relativePaths) {
+      const posix = toPosix(relativePath);
+      const dir = posix.slice(0, posix.lastIndexOf("/"));
+      locations.push({
+        ecosystem,
+        dir,
+        name: dir.slice(dir.lastIndexOf("/") + 1),
+        manifestPath: (0, import_node_path20.join)(workspaceRoot, relativePath)
+      });
+    }
+  }
+  return locations;
+}
 function rewriteSpec(site, spec) {
   if (!site.rewritable || spec === site.spec) {
     return false;
@@ -5326,6 +5401,41 @@ function replacePipSpec(content, name, spec) {
     (match, lead, matched) => `${lead}${matched}${spec}`
   );
 }
+function addPipDependency(content, entry) {
+  const name = parseRequirement(entry)?.name;
+  const already = name !== void 0 && pyprojectDependencies(content).some((existing) => parseRequirement(existing)?.name === name);
+  if (already) {
+    return content;
+  }
+  const newline = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/);
+  const quoted = `"${entry}"`;
+  let inProjectTable = false;
+  for (let index = 0; index < lines.length; index++) {
+    const trimmed = lines[index].trim();
+    if (trimmed.startsWith("[")) {
+      inProjectTable = trimmed === "[project]";
+      continue;
+    }
+    if (!inProjectTable) {
+      continue;
+    }
+    const opener = /^(\s*)dependencies\s*=\s*\[(.*)$/.exec(lines[index]);
+    if (!opener) {
+      continue;
+    }
+    const [, indent, rest] = opener;
+    if (rest.includes("]")) {
+      const inner = rest.slice(0, rest.lastIndexOf("]")).trim().replace(/,+\s*$/, "");
+      const list = inner.length > 0 ? `${inner}, ${quoted}` : quoted;
+      lines[index] = `${indent}dependencies = [${list}]`;
+    } else {
+      lines.splice(index + 1, 0, `${indent}    ${quoted},`);
+    }
+    return lines.join(newline);
+  }
+  return content;
+}
 function replacePubSpec(content, name, spec) {
   return content.replaceAll(
     new RegExp(String.raw`^(\s+${escapeForRegex(name)}:[^\S\n]*)\S[^\n]*$`, "gm"),
@@ -5397,6 +5507,158 @@ function resolvedVersion(workspaceRoot, ecosystem, name) {
   return void 0;
 }
 
+// src/dependency-management/install-dependencies.use-case.ts
+var WHOLE_WORKSPACE_INSTALL = [
+  ["npm", "npm", ["install"]],
+  ["pip", "npm", ["run", "python:install"]],
+  ["pub", "flutter", ["pub", "get"]],
+  ["nuget", "npx", ["nx", "run-many", "-t", "restore"]],
+  ["go", "go", ["work", "sync"]]
+];
+function runInstall(workspaceRoot, packages, options = {}) {
+  const targets = options.workspace ?? [];
+  if (targets.length === 0) {
+    if (packages.length > 0) {
+      logger.error(
+        "Adding a package needs a target project \u2014 'mnci install -w <project> <package>'. A bare 'mnci install' (no package) installs the whole workspace"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    installEverything(workspaceRoot);
+    return;
+  }
+  const locations = locateProjects(workspaceRoot);
+  for (const target of targets) {
+    const location = resolveTarget(locations, target);
+    if (location === void 0) {
+      logger.error(
+        `No project '${target}' \u2014 looked for a manifest under apps/, libs/, packages/ (and python-packages/). Name it by directory (apps/${target}) or by its basename`
+      );
+      process.exitCode = 1;
+      continue;
+    }
+    installInto(workspaceRoot, location, packages, Boolean(options.saveDev));
+  }
+}
+function resolveTarget(locations, target) {
+  const byDir = locations.find((location) => location.dir === target);
+  if (byDir !== void 0) {
+    return byDir;
+  }
+  const byName = locations.filter((location) => location.name === target);
+  if (byName.length > 1) {
+    logger.error(
+      `'${target}' matches ${byName.length} projects (${byName.map((match) => match.dir).join(", ")}) \u2014 name it by directory`
+    );
+    return void 0;
+  }
+  return byName[0];
+}
+function installInto(workspaceRoot, location, packages, saveDev) {
+  const projectDir = (0, import_node_path21.join)(workspaceRoot, location.dir);
+  switch (location.ecosystem) {
+    case "npm": {
+      const flags = saveDev ? ["--save-dev"] : [];
+      shell(workspaceRoot, "npm", ["install", ...packages, ...flags, "-w", location.dir], location);
+      return;
+    }
+    case "go": {
+      shell(projectDir, "go", packages.length > 0 ? ["get", ...packages] : ["mod", "download"], location);
+      if (packages.length > 0) {
+        runShell("go", ["work", "sync"], workspaceRoot);
+      }
+      return;
+    }
+    case "nuget": {
+      if (packages.length === 0) {
+        shell(workspaceRoot, "dotnet", ["restore", location.manifestPath], location);
+        return;
+      }
+      for (const specifier of packages) {
+        const [name, version] = splitAtLast(specifier, "@");
+        const versionFlag = version === void 0 ? [] : ["--version", version];
+        shell(workspaceRoot, "dotnet", ["add", location.manifestPath, "package", name, ...versionFlag], location);
+      }
+      return;
+    }
+    case "pub": {
+      const devFlag = saveDev ? ["--dev"] : [];
+      shell(
+        projectDir,
+        "flutter",
+        packages.length > 0 ? ["pub", "add", ...devFlag, ...packages] : ["pub", "get"],
+        location
+      );
+      return;
+    }
+    case "pip": {
+      if (saveDev) {
+        logger.warn(
+          "pip has no per-project dev-dependency section \u2014 adding to [project].dependencies (dev tools live in the root requirements-dev.txt)"
+        );
+      }
+      for (const specifier of packages) {
+        addPythonDependency(location.manifestPath, specifier);
+      }
+      installEverything(workspaceRoot, ["pip"]);
+      return;
+    }
+  }
+}
+function addPythonDependency(manifestPath, specifier) {
+  let content;
+  try {
+    content = (0, import_node_fs17.readFileSync)(manifestPath, "utf8");
+  } catch {
+    logger.warn(`Could not read ${manifestPath} \u2014 skipped ${specifier}`);
+    return;
+  }
+  const updated = addPipDependency(content, specifier);
+  if (updated === content) {
+    logger.info(`${specifier} is already declared \u2014 left as is`);
+    return;
+  }
+  writeFileEnsured(manifestPath, updated);
+  logger.step(`Added ${specifier} to ${manifestPath}`);
+}
+function installEverything(workspaceRoot, only) {
+  for (const [ecosystem, command, arguments_] of WHOLE_WORKSPACE_INSTALL) {
+    if (only !== void 0 && !only.includes(ecosystem)) {
+      continue;
+    }
+    if (!ecosystemPresent(workspaceRoot, ecosystem)) {
+      continue;
+    }
+    logger.step(`Installing ${ecosystem} dependencies (${command} ${arguments_.join(" ")})`);
+    if (runShell(command, [...arguments_], workspaceRoot) !== 0) {
+      logger.warn(`${command} ${arguments_.join(" ")} failed \u2014 re-run it once the cause is fixed`);
+    }
+  }
+}
+function ecosystemPresent(workspaceRoot, ecosystem) {
+  if (ecosystem === "go") {
+    return fileExists((0, import_node_path21.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path21.join)(workspaceRoot, "go.mod"));
+  }
+  return hasEcosystem(workspaceRoot, ecosystem);
+}
+function shell(cwd, command, arguments_, location) {
+  logger.step(`${location.dir}: ${command} ${arguments_.join(" ")}`);
+  if (runShell(command, [...arguments_], cwd) !== 0) {
+    logger.warn(`${command} ${arguments_.join(" ")} failed in ${location.dir}`);
+  }
+}
+function splitAtLast(value, separator) {
+  const at = value.lastIndexOf(separator);
+  if (at <= 0) {
+    return [value, void 0];
+  }
+  return [value.slice(0, at), value.slice(at + 1)];
+}
+
+// src/dependency-management/sync-dependencies.use-case.ts
+var import_node_path22 = require("path");
+
 // src/dependency-management/semver.algorithm.ts
 var UPDATE_KINDS = ["patch", "minor", "major", "non-semver"];
 var UPDATE_KIND_LABELS = {
@@ -5572,7 +5834,7 @@ function describe(finding) {
   return `${finding.name} \u2192 ${finding.target} (${finding.reason}); disagreeing: ${sites}`;
 }
 function runSync(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path21.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path22.join)(workspaceRoot, "nx.json"))) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 run 'mnci sync' from the workspace root.`
     );
@@ -5622,7 +5884,7 @@ function runSync(workspaceRoot, options) {
 }
 
 // src/dependency-management/update-dependencies.use-case.ts
-var import_node_path22 = require("path");
+var import_node_path23 = require("path");
 var import_prompts2 = require("@inquirer/prompts");
 
 // src/dependency-management/registry.client.ts
@@ -5905,7 +6167,7 @@ function reinstall(workspaceRoot, ecosystems) {
 function hasPythonInstallScript(workspaceRoot) {
   try {
     const manifest = readJson(
-      (0, import_node_path22.join)(workspaceRoot, "package.json")
+      (0, import_node_path23.join)(workspaceRoot, "package.json")
     );
     return manifest.scripts?.["python:install"] !== void 0;
   } catch {
@@ -5921,7 +6183,7 @@ function applyGoUpdates(workspaceRoot, entries) {
   }
 }
 async function runUp(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path22.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path23.join)(workspaceRoot, "nx.json"))) {
     throw new Error(`No nx.json found in ${workspaceRoot} \u2014 run 'mnci up' from the workspace root.`);
   }
   const ecosystems = resolveEcosystems(options.ecosystem);
@@ -5997,7 +6259,7 @@ var PROJECT_KINDS = [
 ];
 async function runAdd(kind, name, options) {
   const workspaceRoot = process.cwd();
-  if (!fileExists((0, import_node_path23.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path24.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `add` from the workspace root.");
   }
   const stack = readWorkspaceStack(workspaceRoot);
@@ -6057,8 +6319,8 @@ async function runAdd(kind, name, options) {
         ],
         workspaceRoot
       );
-      markPrivate((0, import_node_path23.join)(workspaceRoot, "libs", resolvedName, "package.json"));
-      renameScaffoldPlaceholder((0, import_node_path23.join)(workspaceRoot, "libs", resolvedName), resolvedName);
+      markPrivate((0, import_node_path24.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      renameScaffoldPlaceholder((0, import_node_path24.join)(workspaceRoot, "libs", resolvedName), resolvedName);
       removeGeneratedEslintConfig(workspaceRoot, `libs/${resolvedName}`);
       registerProjectCommands(workspaceRoot, resolvedName, { build: true });
       break;
@@ -6150,7 +6412,7 @@ async function runAdd(kind, name, options) {
 }
 function readWorkspaceStack(workspaceRoot) {
   const nxJson = readJson(
-    (0, import_node_path23.join)(workspaceRoot, "nx.json")
+    (0, import_node_path24.join)(workspaceRoot, "nx.json")
   );
   const stack = nxJson.mnci?.stack;
   return {
@@ -6160,15 +6422,15 @@ function readWorkspaceStack(workspaceRoot) {
 
 // src/workspace-diagnostics/check-invariants.use-case.ts
 var import_node_child_process = require("child_process");
-var import_node_fs17 = require("fs");
-var import_node_path24 = require("path");
+var import_node_fs18 = require("fs");
+var import_node_path25 = require("path");
 var SUPPORTED_ESLINT_MAJOR = ESLINT_VERSION.replace(/^\D*/, "").split(".", 1)[0];
 function toPosix2(path) {
   return path.replaceAll("\\", "/");
 }
 function checkEslintConfigs(workspaceRoot) {
-  const rootConfigs = (0, import_node_fs17.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
-  const projectConfigs = (0, import_node_fs17.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
+  const rootConfigs = (0, import_node_fs18.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
+  const projectConfigs = (0, import_node_fs18.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return [
@@ -6188,10 +6450,10 @@ function checkEslintConfigs(workspaceRoot) {
   ];
 }
 function checkEslintEntryPointReachesTheRules(workspaceRoot) {
-  const rules = (0, import_node_path24.join)(workspaceRoot, ESLINT_MNCI_FILENAME);
-  if (!(0, import_node_fs17.existsSync)(rules)) return [];
-  const entryPoint = (0, import_node_path24.join)(workspaceRoot, ESLINT_USER_FILENAME);
-  const source = (0, import_node_fs17.existsSync)(entryPoint) ? (0, import_node_fs17.readFileSync)(entryPoint, "utf8") : "";
+  const rules = (0, import_node_path25.join)(workspaceRoot, ESLINT_MNCI_FILENAME);
+  if (!(0, import_node_fs18.existsSync)(rules)) return [];
+  const entryPoint = (0, import_node_path25.join)(workspaceRoot, ESLINT_USER_FILENAME);
+  const source = (0, import_node_fs18.existsSync)(entryPoint) ? (0, import_node_fs18.readFileSync)(entryPoint, "utf8") : "";
   return [
     {
       check: `${ESLINT_USER_FILENAME} imports the mnci rules`,
@@ -6204,7 +6466,7 @@ function checkEslintEntryPointReachesTheRules(workspaceRoot) {
 function declaredDevDependencies(workspaceRoot) {
   try {
     const manifest = readJson(
-      (0, import_node_path24.join)(workspaceRoot, "package.json")
+      (0, import_node_path25.join)(workspaceRoot, "package.json")
     );
     return manifest.devDependencies ?? {};
   } catch {
@@ -6212,7 +6474,7 @@ function declaredDevDependencies(workspaceRoot) {
   }
 }
 function checkNoRetiredFormatter(workspaceRoot) {
-  const files = RETIRED_FORMATTER_FILES.filter((file) => fileExists((0, import_node_path24.join)(workspaceRoot, file)));
+  const files = RETIRED_FORMATTER_FILES.filter((file) => fileExists((0, import_node_path25.join)(workspaceRoot, file)));
   const declared = ["prettier", "eslint-config-prettier", "oxlint", "oxfmt", "@mnci/oxlint-config"].filter((name) => declaredDevDependencies(workspaceRoot)[name] !== void 0);
   const stale = [...files, ...declared];
   if (stale.length === 0) {
@@ -6238,7 +6500,7 @@ function checkEslintPlugin(nxJson) {
   };
 }
 function checkResolvedEslint(workspaceRoot) {
-  const manifestPath = (0, import_node_path24.join)(workspaceRoot, "node_modules/eslint/package.json");
+  const manifestPath = (0, import_node_path25.join)(workspaceRoot, "node_modules/eslint/package.json");
   if (!fileExists(manifestPath)) {
     return void 0;
   }
@@ -6256,11 +6518,11 @@ function checkResolvedEslint(workspaceRoot) {
   }
 }
 function checkNpmrc(workspaceRoot, registry, scope) {
-  const npmrcPath = (0, import_node_path24.join)(workspaceRoot, ".npmrc");
+  const npmrcPath = (0, import_node_path25.join)(workspaceRoot, ".npmrc");
   if (!registry || !fileExists(npmrcPath)) {
     return void 0;
   }
-  const npmrc = (0, import_node_fs17.readFileSync)(npmrcPath, "utf8");
+  const npmrc = (0, import_node_fs18.readFileSync)(npmrcPath, "utf8");
   if (registry.kind === "npm") {
     return {
       check: ".npmrc authenticates the public registry",
@@ -6277,11 +6539,11 @@ function checkNpmrc(workspaceRoot, registry, scope) {
   };
 }
 function checkNpmrcCredentialResolves(workspaceRoot, environment = process.env) {
-  const npmrcPath = (0, import_node_path24.join)(workspaceRoot, ".npmrc");
+  const npmrcPath = (0, import_node_path25.join)(workspaceRoot, ".npmrc");
   if (!fileExists(npmrcPath)) {
     return void 0;
   }
-  const npmrc = (0, import_node_fs17.readFileSync)(npmrcPath, "utf8");
+  const npmrc = (0, import_node_fs18.readFileSync)(npmrcPath, "utf8");
   const credentials = npmrc.split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).filter((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
   const referenced = [
     ...new Set(
@@ -6305,13 +6567,13 @@ function checkNpmrcCredentialResolves(workspaceRoot, environment = process.env)
   };
 }
 function checkNpmAuthMatchesPipeline(workspaceRoot, registry) {
-  const npmrcPath = (0, import_node_path24.join)(workspaceRoot, ".npmrc");
-  const pipelinePath = (0, import_node_path24.join)(workspaceRoot, "azure-pipelines.yml");
+  const npmrcPath = (0, import_node_path25.join)(workspaceRoot, ".npmrc");
+  const pipelinePath = (0, import_node_path25.join)(workspaceRoot, "azure-pipelines.yml");
   if (registry?.kind !== "azure-artifacts" || !fileExists(npmrcPath) || !fileExists(pipelinePath)) {
     return void 0;
   }
-  const holdsCredentials = (0, import_node_fs17.readFileSync)(npmrcPath, "utf8").split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).some((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
-  const runsTask = (0, import_node_fs17.readFileSync)(pipelinePath, "utf8").includes("npmAuthenticate@0");
+  const holdsCredentials = (0, import_node_fs18.readFileSync)(npmrcPath, "utf8").split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).some((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
+  const runsTask = (0, import_node_fs18.readFileSync)(pipelinePath, "utf8").includes("npmAuthenticate@0");
   if (!holdsCredentials && !runsTask) {
     return {
       check: "npm auth: .npmrc and azure-pipelines.yml agree",
@@ -6356,13 +6618,13 @@ function npmjsCredentialShape(credentials, environment) {
 }
 function checkVersionActions(workspaceRoot) {
   const candidates = [
-    ...(0, import_node_fs17.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
-    ...(0, import_node_fs17.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
-    ...(0, import_node_fs17.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
+    ...(0, import_node_fs18.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
+    ...(0, import_node_fs18.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
+    ...(0, import_node_fs18.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
   ].map((manifest) => toPosix2(manifest));
   return candidates.flatMap((manifest) => {
     const projectRoot = manifest.slice(0, manifest.lastIndexOf("/"));
-    const projectJsonPath = (0, import_node_path24.join)(workspaceRoot, projectRoot, "project.json");
+    const projectJsonPath = (0, import_node_path25.join)(workspaceRoot, projectRoot, "project.json");
     let hasOverride = false;
     try {
       const projectJson = readJson(projectJsonPath);
@@ -6391,7 +6653,7 @@ function declaredTargets(workspaceRoot, projectRoot) {
   ]) {
     try {
       const targets = extract(
-        readJson((0, import_node_path24.join)(workspaceRoot, projectRoot, file))
+        readJson((0, import_node_path25.join)(workspaceRoot, projectRoot, file))
       );
       if (targets && typeof targets === "object") {
         sources.push({
@@ -6407,8 +6669,8 @@ function declaredTargets(workspaceRoot, projectRoot) {
 function checkTargetFilesExist(workspaceRoot) {
   const projectRoots = new Set(
     [
-      ...(0, import_node_fs17.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
-      ...(0, import_node_fs17.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
+      ...(0, import_node_fs18.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
+      ...(0, import_node_fs18.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
     ].map((manifest) => toPosix2(manifest).split("/").slice(0, 2).join("/"))
   );
   return [...projectRoots].flatMap(
@@ -6423,7 +6685,7 @@ function checkOneTargetsFiles(workspaceRoot, source, targetName, target) {
   return TARGET_FILE_OPTIONS.flatMap((option) => {
     const value = target?.options?.[option];
     const checkable = typeof value === "string" && !value.includes("{");
-    if (!checkable || fileExists((0, import_node_path24.join)(workspaceRoot, value))) {
+    if (!checkable || fileExists((0, import_node_path25.join)(workspaceRoot, value))) {
       return [];
     }
     return [
@@ -6459,6 +6721,23 @@ function checkGoPluginRegistered(workspaceRoot) {
     remedy: "run `mnci upgrade`"
   };
 }
+function checkGoWorkInSync(workspaceRoot) {
+  const goWorkPath = (0, import_node_path25.join)(workspaceRoot, "go.work");
+  if (!fileExists(goWorkPath)) {
+    return void 0;
+  }
+  const contents = (0, import_node_fs18.existsSync)(goWorkPath) ? (0, import_node_fs18.readFileSync)(goWorkPath, "utf8") : "";
+  const blockEntries = Array.from(contents.matchAll(/(?:^|\n)\s*use\s+\(([^)]*)\)/g), (match) => match[1].split("\n")).flat();
+  const singleEntries = Array.from(contents.matchAll(/(?:^|\n)\s*use\s+(\.\S+)/g), (match) => match[1]);
+  const uses = [...blockEntries, ...singleEntries].map((entry) => entry.trim()).filter(Boolean);
+  const stale = uses.filter((entry) => !(0, import_node_fs18.existsSync)((0, import_node_path25.join)(workspaceRoot, entry, "go.mod")));
+  return {
+    check: "every go.work `use` entry points to a module that still exists",
+    ok: stale.length === 0,
+    detail: `go.work lists ${stale.join(", ")} but there is no go.mod there \u2014 \`go list -m\` fails, which breaks the whole Nx project graph`,
+    remedy: "drop the stale `use` line(s) from go.work (mnci owns the file; a removed Go project should have its entry removed)"
+  };
+}
 function checkNativeApps(workspaceRoot) {
   if (!hasNativeGoApp(workspaceRoot)) {
     return [];
@@ -6467,9 +6746,9 @@ function checkNativeApps(workspaceRoot) {
     { file: ".github/workflows/ci.yml", marker: "native (${{ matrix.os }})" },
     { file: "azure-pipelines.yml", marker: "- job: native" }
   ];
-  const findings = pipelines.filter(({ file }) => fileExists((0, import_node_path24.join)(workspaceRoot, file))).map(({ file, marker }) => ({
+  const findings = pipelines.filter(({ file }) => fileExists((0, import_node_path25.join)(workspaceRoot, file))).map(({ file, marker }) => ({
     check: `${file} builds the native apps on every OS`,
-    ok: (0, import_node_fs17.readFileSync)((0, import_node_path24.join)(workspaceRoot, file), "utf8").includes(marker),
+    ok: (0, import_node_fs18.readFileSync)((0, import_node_path25.join)(workspaceRoot, file), "utf8").includes(marker),
     detail: `${file} has no native job: CI would verify a cgo app on the one agent that cannot build it`,
     remedy: "run `mnci upgrade`"
   }));
@@ -6482,7 +6761,7 @@ function checkNativeApps(workspaceRoot) {
   return findings;
 }
 function checkNoRootRuntimeDependencies(workspaceRoot) {
-  const manifestPath = (0, import_node_path24.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path25.join)(workspaceRoot, "package.json");
   if (!fileExists(manifestPath)) {
     return void 0;
   }
@@ -6502,14 +6781,14 @@ function checkNoRootRuntimeDependencies(workspaceRoot) {
   };
 }
 function checkRollupSourceMaps(workspaceRoot) {
-  const configs = (0, import_node_fs17.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs18.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return configs.flatMap((relativePath) => {
-    const configPath = (0, import_node_path24.join)(workspaceRoot, relativePath);
+    const configPath = (0, import_node_path25.join)(workspaceRoot, relativePath);
     let config;
     try {
-      config = (0, import_node_fs17.readFileSync)(configPath, "utf8");
+      config = (0, import_node_fs18.readFileSync)(configPath, "utf8");
     } catch {
       return [];
     }
@@ -6524,11 +6803,11 @@ function checkRollupSourceMaps(workspaceRoot) {
   });
 }
 function checkDeclarationSpecifiers(workspaceRoot) {
-  const configs = (0, import_node_fs17.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs18.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return configs.flatMap((relativePath) => {
-    const configPath = (0, import_node_path24.join)(workspaceRoot, relativePath);
+    const configPath = (0, import_node_path25.join)(workspaceRoot, relativePath);
     if (!fileExists(configPath)) {
       return [];
     }
@@ -6562,7 +6841,7 @@ function checkDeclarationSpecifiers(workspaceRoot) {
   });
 }
 function collectFindings(workspaceRoot) {
-  const nxJsonPath = (0, import_node_path24.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path25.join)(workspaceRoot, "nx.json");
   if (!fileExists(nxJsonPath)) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 run 'mnci doctor' from the workspace root.`
@@ -6584,6 +6863,7 @@ function collectFindings(workspaceRoot) {
     ...checkTargetFilesExist(workspaceRoot),
     checkSync(workspaceRoot),
     checkGoPluginRegistered(workspaceRoot),
+    checkGoWorkInSync(workspaceRoot),
     ...checkNativeApps(workspaceRoot)
   ].filter((finding) => finding !== void 0);
 }
@@ -6609,8 +6889,8 @@ function runDoctor(workspaceRoot) {
 }
 
 // src/workspace-creation/adopt-directory.use-case.ts
-var import_node_fs18 = require("fs");
-var import_node_path25 = require("path");
+var import_node_fs19 = require("fs");
+var import_node_path26 = require("path");
 var NEVER_COPIED = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var AGENT_AND_CI_ENTRIES = [
   "AGENTS.md",
@@ -6641,13 +6921,13 @@ var PREFLIGHT_BLOCKERS = [
   "packages"
 ];
 function assertAdoptableDirectory(target) {
-  if (!(0, import_node_fs18.existsSync)(target)) {
+  if (!(0, import_node_fs19.existsSync)(target)) {
     throw new Error(`--into '${target}' does not exist. Create or clone it first.`);
   }
-  if (!(0, import_node_fs18.statSync)(target).isDirectory()) {
+  if (!(0, import_node_fs19.statSync)(target).isDirectory()) {
     throw new Error(`--into '${target}' is not a directory.`);
   }
-  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs18.existsSync)((0, import_node_path25.join)(target, entry)));
+  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs19.existsSync)((0, import_node_path26.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.`
@@ -6655,15 +6935,15 @@ function assertAdoptableDirectory(target) {
   }
 }
 function mergeGitignore(generatedFile, targetFile) {
-  const existing = (0, import_node_fs18.readFileSync)(targetFile, "utf8");
+  const existing = (0, import_node_fs19.readFileSync)(targetFile, "utf8");
   const present = new Set(existing.split("\n").map((line) => line.trim()));
-  const additions = (0, import_node_fs18.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
+  const additions = (0, import_node_fs19.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_fs18.writeFileSync)(
+  (0, import_node_fs19.writeFileSync)(
     targetFile,
     `${existing}${separator}
 # Added by mnci (Nx workspace)
@@ -6673,9 +6953,9 @@ ${additions.join("\n")}
   return true;
 }
 function adoptGeneratedWorkspace(generatedRoot, target) {
-  const entries = (0, import_node_fs18.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
+  const entries = (0, import_node_fs19.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
   const collisions = entries.filter(
-    (entry) => (0, import_node_fs18.existsSync)((0, import_node_path25.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
+    (entry) => (0, import_node_fs19.existsSync)((0, import_node_path26.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
   );
   if (collisions.length > 0) {
     throw new Error(
@@ -6684,28 +6964,28 @@ function adoptGeneratedWorkspace(generatedRoot, target) {
   }
   const result = { copied: [], kept: [], mergedGitignore: false };
   for (const entry of entries) {
-    const from = (0, import_node_path25.join)(generatedRoot, entry);
-    const to = (0, import_node_path25.join)(target, entry);
-    if (entry === ".gitignore" && (0, import_node_fs18.existsSync)(to)) {
+    const from = (0, import_node_path26.join)(generatedRoot, entry);
+    const to = (0, import_node_path26.join)(target, entry);
+    if (entry === ".gitignore" && (0, import_node_fs19.existsSync)(to)) {
       result.mergedGitignore = mergeGitignore(from, to);
       result.kept.push(entry);
       continue;
     }
-    if ((0, import_node_fs18.existsSync)(to)) {
+    if ((0, import_node_fs19.existsSync)(to)) {
       result.kept.push(entry);
       continue;
     }
-    (0, import_node_fs18.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs19.cpSync)(from, to, { recursive: true });
     result.copied.push(entry);
   }
-  (0, import_node_fs18.rmSync)(generatedRoot, { recursive: true, force: true });
+  (0, import_node_fs19.rmSync)(generatedRoot, { recursive: true, force: true });
   return result;
 }
 
 // src/workspace-creation/create-workspace.use-case.ts
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_os = require("os");
-var import_node_path26 = require("path");
+var import_node_path27 = require("path");
 function nxCloudProviderValue(ci) {
   return ci === "azure" ? "azure" : "github";
 }
@@ -6748,9 +7028,9 @@ async function resolveRegistry(options) {
   return await promptRegistry();
 }
 async function runNew(name, options) {
-  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path26.resolve)(process.cwd(), options.into);
+  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path27.resolve)(process.cwd(), options.into);
   if (adoptTarget !== void 0) assertAdoptableDirectory(adoptTarget);
-  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path26.basename)(adoptTarget));
+  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path27.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);
@@ -6763,8 +7043,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_fs19.mkdtempSync)((0, import_node_path26.join)((0, import_node_os.tmpdir)(), "mnci-new-"));
-  let workspaceRoot = (0, import_node_path26.join)(stagingParent, workspaceName);
+  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs20.mkdtempSync)((0, import_node_path27.join)((0, import_node_os.tmpdir)(), "mnci-new-"));
+  let workspaceRoot = (0, import_node_path27.join)(stagingParent, workspaceName);
   try {
     logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
     runNpx(
@@ -6787,7 +7067,7 @@ async function runNew(name, options) {
       workspaceRoot = adoptTarget;
     }
   } finally {
-    if (adoptTarget !== void 0) (0, import_node_fs19.rmSync)(stagingParent, { recursive: true, force: true });
+    if (adoptTarget !== void 0) (0, import_node_fs20.rmSync)(stagingParent, { recursive: true, force: true });
   }
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
@@ -6797,8 +7077,8 @@ async function runNew(name, options) {
     { workspaceName, scope, registry, agent, variableGroup, ci, stack, ...npmAuth && { npmAuth } },
     logger.detail
   );
-  (0, import_node_fs19.rmSync)((0, import_node_path26.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs19.rmSync)((0, import_node_path26.join)(workspaceRoot, "package-lock.json"), { force: true });
+  (0, import_node_fs20.rmSync)((0, import_node_path27.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs20.rmSync)((0, import_node_path27.join)(workspaceRoot, "package-lock.json"), { force: true });
   logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",
@@ -6836,12 +7116,12 @@ function projectKindHintLines(kinds = PROJECT_KINDS) {
 }
 
 // src/workspace-creation/interactive-wizard.use-case.ts
-var import_node_path28 = require("path");
+var import_node_path29 = require("path");
 var import_prompts4 = require("@inquirer/prompts");
 
 // src/workspace-upgrade/upgrade-workspace.use-case.ts
-var import_node_fs20 = require("fs");
-var import_node_path27 = require("path");
+var import_node_fs21 = require("fs");
+var import_node_path28 = require("path");
 function resolveRegistry2(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
     const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
@@ -6870,7 +7150,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     return persisted.workspaceName;
   }
   try {
-    const existing = (0, import_node_fs20.readdirSync)(workspaceRoot).find(
+    const existing = (0, import_node_fs21.readdirSync)(workspaceRoot).find(
       (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
     );
     if (existing) {
@@ -6878,11 +7158,11 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     }
   } catch {
   }
-  return (0, import_node_path27.basename)(workspaceRoot);
+  return (0, import_node_path28.basename)(workspaceRoot);
 }
 function detectNpmAuth(workspaceRoot) {
   try {
-    return (0, import_node_fs20.readFileSync)((0, import_node_path27.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
+    return (0, import_node_fs21.readFileSync)((0, import_node_path28.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
   } catch {
     return void 0;
   }
@@ -6929,7 +7209,7 @@ function resolveOverlayOptions(workspaceRoot, options, persisted) {
   };
 }
 function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path27.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path28.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.`
     );
@@ -6994,7 +7274,7 @@ function runUpgrade(workspaceRoot, options) {
 
 // src/workspace-creation/interactive-wizard.use-case.ts
 async function runInteractive() {
-  const inWorkspace = fileExists((0, import_node_path28.join)(process.cwd(), "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path29.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 = {
@@ -7015,8 +7295,8 @@ async function runInteractive() {
 }
 
 // src/cli-version/check-for-update.use-case.ts
-var import_node_fs21 = require("fs");
-var import_node_path29 = require("path");
+var import_node_fs22 = require("fs");
+var import_node_path30 = require("path");
 var import_cross_spawn2 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
@@ -7072,8 +7352,8 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path29.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs21.readFileSync)(manifestPath, "utf8"));
+    const manifestPath = (0, import_node_path30.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs22.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -7127,6 +7407,11 @@ function buildProgram(cliVersion) {
   ).option("--check", "report only; never prompt and never write (the default when piped)").option("-y, --yes", "select every available update without prompting").option("--ecosystem <name>", "restrict to one ecosystem: npm | pip | pub | go").option("--no-install", "update the manifests but skip the reinstall step").action(async (options) => {
     await runUp(process.cwd(), options);
   });
+  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) => {
+    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)"