@mnci/cli 1.9.1 → 1.10.0

package/dist/cli.js

@@ -38,7 +38,7 @@ module.exports = __toCommonJS(cli_exports);
 var import_commander = require("commander");
 
 // src/commands/add.ts
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 var import_prompts4 = require("@inquirer/prompts");
 
 // src/nx.ts
@@ -164,7 +164,11 @@ function assertValidProjectName(name, label) {
   }
 }
 
+// src/commands/add/flutter.ts
+var import_node_path3 = require("path");
+
 // src/commands/add/shared.ts
+var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 function hasPlugin(workspaceRoot, packageName) {
   const manifest = readJson((0, import_node_path2.join)(workspaceRoot, "package.json"));
@@ -198,8 +202,79 @@ function addNxTargets(manifestPath, newTargets) {
     toJson({ ...manifest, nx: { ...nx, targets: { ...targets, ...newTargets } } })
   );
 }
+function findCodeWorkspaceFile(workspaceRoot) {
+  try {
+    const entry = (0, import_node_fs2.readdirSync)(workspaceRoot).find((file) => file.endsWith(".code-workspace"));
+    return entry ? (0, import_node_path2.join)(workspaceRoot, entry) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readCodeWorkspaceFile(path) {
+  const contents = (0, import_node_fs2.readFileSync)(path, "utf8").replaceAll(/,(\s*[}\]])/g, "$1");
+  return JSON.parse(contents);
+}
+function projectTask(name, kind) {
+  const script = `${name}:${kind}`;
+  const base = { label: `${name}: ${kind}`, type: "npm", script, problemMatcher: [] };
+  return kind === "start" ? { ...base, isBackground: true } : { ...base, group: kind };
+}
+function registerProjectCommands(workspaceRoot, name, commands) {
+  const scripts = {
+    [`${name}:qa`]: `nx run ${name}:lint && nx run ${name}:test`
+  };
+  if (commands.build) {
+    scripts[`${name}:build`] = `nx run ${name}:build`;
+  }
+  if (commands.start) {
+    scripts[`${name}:start`] = commands.start;
+  }
+  const manifestPath = (0, import_node_path2.join)(workspaceRoot, "package.json");
+  const manifest = readJson(manifestPath);
+  const existingScripts = manifest.scripts ?? {};
+  writeFileEnsured(
+    manifestPath,
+    toJson({ ...manifest, scripts: { ...existingScripts, ...scripts } })
+  );
+  const codeWorkspacePath = findCodeWorkspaceFile(workspaceRoot);
+  if (!codeWorkspacePath) {
+    return;
+  }
+  const workspaceFile = readCodeWorkspaceFile(codeWorkspacePath);
+  const label = (task) => task.label ?? "";
+  const existingTasks = (workspaceFile.tasks?.tasks ?? []).filter(
+    (task) => !label(task).startsWith(`${name}: `)
+  );
+  const newTasks = [
+    projectTask(name, "qa"),
+    ...commands.build ? [projectTask(name, "build")] : [],
+    ...commands.start ? [projectTask(name, "start")] : []
+  ];
+  writeFileEnsured(
+    codeWorkspacePath,
+    toJson({
+      ...workspaceFile,
+      tasks: {
+        version: workspaceFile.tasks?.version ?? "2.0.0",
+        tasks: [...existingTasks, ...newTasks]
+      }
+    })
+  );
+}
 
 // src/commands/add/flutter.ts
+function addProjectJsonTargets(projectJsonPath, newTargets) {
+  const project = readJson(projectJsonPath);
+  const targets = project.targets ?? {};
+  writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
+}
+function flutterAppStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    continuous: true,
+    options: { command: "flutter run -d chrome", cwd: `apps/${name}` }
+  };
+}
 function ensureFlutter(workspaceRoot) {
   if (runShell("flutter", ["--version"], workspaceRoot) !== 0) {
     throw new Error(
@@ -228,19 +303,25 @@ function addFlutterApp(workspaceRoot, name) {
   prepareFlutter(workspaceRoot);
   ensureAdmZip(workspaceRoot);
   runNx(["g", "@mnci/nx-flutter:application", name, "--no-interactive"], workspaceRoot);
+  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "project.json"), {
+    start: flutterAppStartTarget(name)
+  });
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 function addFlutterLib(workspaceRoot, name) {
   prepareFlutter(workspaceRoot);
   runNx(["g", "@mnci/nx-flutter:library", name, "--no-interactive"], workspaceRoot);
+  registerProjectCommands(workspaceRoot, name, { build: false });
 }
 function addFlutterInternalLib(workspaceRoot, name) {
   prepareFlutter(workspaceRoot);
   runNx(["g", "@mnci/nx-flutter:internal-library", name, "--no-interactive"], workspaceRoot);
+  registerProjectCommands(workspaceRoot, name, { build: false });
 }
 
 // src/commands/add/go.ts
-var import_node_fs2 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
 function ensureGo(workspaceRoot) {
   if (runShell("go", ["version"], workspaceRoot) !== 0) {
     throw new Error("Go not found. Install Go 1.21+ first: https://go.dev/dl/");
@@ -267,7 +348,7 @@ function ensureNxGoPlugin(workspaceRoot) {
   }
 }
 function ensureGoModule(workspaceRoot) {
-  if (fileExists((0, import_node_path3.join)(workspaceRoot, "go.mod"))) {
+  if (fileExists((0, import_node_path4.join)(workspaceRoot, "go.mod"))) {
     return;
   }
   logger.step("Bootstrapping the workspace Go module (single root go.mod)");
@@ -276,13 +357,13 @@ function ensureGoModule(workspaceRoot) {
 }
 function goModulePath(workspaceRoot) {
   try {
-    const contents = (0, import_node_fs2.readFileSync)((0, import_node_path3.join)(workspaceRoot, "go.mod"), "utf8");
+    const contents = (0, import_node_fs3.readFileSync)((0, import_node_path4.join)(workspaceRoot, "go.mod"), "utf8");
     return /^module\s+(\S+)/m.exec(contents)?.[1];
   } catch {
     return void 0;
   }
 }
-function addProjectJsonTargets(projectJsonPath, newTargets) {
+function addProjectJsonTargets2(projectJsonPath, newTargets) {
   const project = readJson(projectJsonPath);
   const targets = project.targets ?? {};
   writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
@@ -312,6 +393,13 @@ function goPackageTarget(tag, name) {
     options: { command }
   };
 }
+function goStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    continuous: true,
+    options: { command: "go run .", cwd: `apps/${name}` }
+  };
+}
 function prepareGo(workspaceRoot) {
   ensureGo(workspaceRoot);
   warnIfNoGolangciLint(workspaceRoot);
@@ -332,12 +420,14 @@ function addGoApp(workspaceRoot, name) {
     ],
     workspaceRoot
   );
-  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets2((0, import_node_path4.join)(workspaceRoot, "apps", name, "project.json"), {
     build: goBuildTarget(name),
     test: goTestTarget(),
     lint: goLintTarget(),
-    package: goPackageTarget("go-app", name)
+    package: goPackageTarget("go-app", name),
+    start: goStartTarget(name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 function addGoFunctionApp(workspaceRoot, name) {
   prepareGo(workspaceRoot);
@@ -353,12 +443,13 @@ function addGoFunctionApp(workspaceRoot, name) {
     ],
     workspaceRoot
   );
-  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets2((0, import_node_path4.join)(workspaceRoot, "apps", name, "project.json"), {
     build: goBuildTarget(name),
     test: goTestTarget(),
     lint: goLintTarget(),
     package: goPackageTarget("go-function-app", name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: true });
 }
 function addGoLib(workspaceRoot, name) {
   prepareGo(workspaceRoot);
@@ -373,10 +464,11 @@ function addGoLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
-  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "packages", name, "project.json"), {
+  addProjectJsonTargets2((0, import_node_path4.join)(workspaceRoot, "packages", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
+  registerProjectCommands(workspaceRoot, name, { build: false });
   const module2 = goModulePath(workspaceRoot);
   if (module2) {
     logger.step(`Import it as ${module2}/packages/${name}`);
@@ -395,10 +487,11 @@ function addGoInternalLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
-  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "libs", name, "project.json"), {
+  addProjectJsonTargets2((0, import_node_path4.join)(workspaceRoot, "libs", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
+  registerProjectCommands(workspaceRoot, name, { build: false });
   const module2 = goModulePath(workspaceRoot);
   if (module2) {
     logger.step(`Import it as ${module2}/libs/${name}`);
@@ -406,7 +499,7 @@ function addGoInternalLib(workspaceRoot, name) {
 }
 
 // src/commands/add/node.ts
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 function ensurePlugin(workspaceRoot, packageName) {
   if (hasPlugin(workspaceRoot, packageName)) {
     return;
@@ -445,9 +538,10 @@ function nodeAppPackageTarget(name) {
 function addNodeApp(workspaceRoot, name, stack, framework = "none") {
   runNodeApp(workspaceRoot, name, stack, framework);
   ensureAdmZip(workspaceRoot);
-  addNxTargets((0, import_node_path4.join)(workspaceRoot, "apps", name, "package.json"), {
+  addNxTargets((0, import_node_path5.join)(workspaceRoot, "apps", name, "package.json"), {
     package: nodeAppPackageTarget(name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:serve` });
 }
 function ensureAzureFunctionsPackage(workspaceRoot) {
   if (hasPlugin(workspaceRoot, "@azure/functions")) {
@@ -498,17 +592,17 @@ describe('buildGreeting', () => {
 })
 `;
 function repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot) {
-  const manifestPath = (0, import_node_path4.join)(nodeFunctionAppRoot, "package.json");
+  const manifestPath = (0, import_node_path5.join)(nodeFunctionAppRoot, "package.json");
   const manifest = readJson(manifestPath);
   const azureFunctionsVersion = readJson(
-    (0, import_node_path4.join)(workspaceRoot, "node_modules/@azure/functions/package.json")
+    (0, import_node_path5.join)(workspaceRoot, "node_modules/@azure/functions/package.json")
   ).version;
   const dependencies = manifest.dependencies ?? {};
   writeFileEnsured(
     manifestPath,
     toJson({
       ...manifest,
-      main: "main.js",
+      main: "dist/main.js",
       dependencies: { ...dependencies, "@azure/functions": `^${azureFunctionsVersion}` }
     })
   );
@@ -516,7 +610,7 @@ function repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot) {
 function nodeFunctionAppPackageTarget(name) {
   const zip = `dist/drop/node-function-app-${name}.zip`;
   const root = `apps/${name}`;
-  const command = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});const A=require('adm-zip');const z=new A();z.addLocalFolder('${root}/dist');z.addLocalFile('${root}/host.json');z.addLocalFile('${root}/package.json');z.writeZip('${zip}')"`;
+  const command = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});const A=require('adm-zip');const z=new A();z.addLocalFolder('${root}/dist','dist');z.addLocalFile('${root}/host.json');z.addLocalFile('${root}/package.json');z.writeZip('${zip}')"`;
   return {
     executor: "nx:run-commands",
     dependsOn: ["build"],
@@ -525,30 +619,40 @@ function nodeFunctionAppPackageTarget(name) {
     options: { command }
   };
 }
+function nodeFunctionAppStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    dependsOn: ["build"],
+    continuous: true,
+    options: { command: "func start", cwd: `apps/${name}` }
+  };
+}
 function addNodeFunctionApp(workspaceRoot, name, stack) {
   runNodeApp(workspaceRoot, name, stack, "none");
   ensureAzureFunctionsPackage(workspaceRoot);
-  const nodeFunctionAppRoot = (0, import_node_path4.join)(workspaceRoot, "apps", name);
-  writeFileEnsured((0, import_node_path4.join)(nodeFunctionAppRoot, "src/main.ts"), NODE_FUNCTION_APP_MAIN);
-  writeFileEnsured((0, import_node_path4.join)(nodeFunctionAppRoot, "src/functions/hello.ts"), NODE_FUNCTION_APP_HELLO);
+  const nodeFunctionAppRoot = (0, import_node_path5.join)(workspaceRoot, "apps", name);
+  writeFileEnsured((0, import_node_path5.join)(nodeFunctionAppRoot, "src/main.ts"), NODE_FUNCTION_APP_MAIN);
+  writeFileEnsured((0, import_node_path5.join)(nodeFunctionAppRoot, "src/functions/hello.ts"), NODE_FUNCTION_APP_HELLO);
   writeFileEnsured(
-    (0, import_node_path4.join)(nodeFunctionAppRoot, "src/functions/greeting.ts"),
+    (0, import_node_path5.join)(nodeFunctionAppRoot, "src/functions/greeting.ts"),
     NODE_FUNCTION_APP_GREETING
   );
   writeFileEnsured(
-    (0, import_node_path4.join)(nodeFunctionAppRoot, "src/functions/greeting.spec.ts"),
+    (0, import_node_path5.join)(nodeFunctionAppRoot, "src/functions/greeting.spec.ts"),
     NODE_FUNCTION_APP_GREETING_SPEC
   );
-  writeFileEnsured((0, import_node_path4.join)(nodeFunctionAppRoot, "host.json"), NODE_FUNCTION_APP_HOST_JSON);
+  writeFileEnsured((0, import_node_path5.join)(nodeFunctionAppRoot, "host.json"), NODE_FUNCTION_APP_HOST_JSON);
   repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot);
   ensureAdmZip(workspaceRoot);
-  addNxTargets((0, import_node_path4.join)(nodeFunctionAppRoot, "package.json"), {
-    package: nodeFunctionAppPackageTarget(name)
+  addNxTargets((0, import_node_path5.join)(nodeFunctionAppRoot, "package.json"), {
+    package: nodeFunctionAppPackageTarget(name),
+    start: nodeFunctionAppStartTarget(name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 
 // src/commands/add/npmLib.ts
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 var NPM_LIB_ESLINT_CONFIG = `import { globSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -616,11 +720,12 @@ async function addNpmLib(workspaceRoot, name, options, kindProvided, stack) {
     ],
     workspaceRoot
   );
-  markPublic((0, import_node_path5.join)(workspaceRoot, "packages", name, "package.json"));
+  markPublic((0, import_node_path6.join)(workspaceRoot, "packages", name, "package.json"));
   writeFileEnsured(
-    (0, import_node_path5.join)(workspaceRoot, "packages", name, "eslint.config.mjs"),
+    (0, import_node_path6.join)(workspaceRoot, "packages", name, "eslint.config.mjs"),
     NPM_LIB_ESLINT_CONFIG
   );
+  registerProjectCommands(workspaceRoot, name, { build: true });
 }
 function markPublic(manifestPath) {
   const manifest = readJson(manifestPath);
@@ -628,8 +733,8 @@ function markPublic(manifestPath) {
 }
 
 // src/commands/add/python.ts
-var import_node_fs3 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path7 = require("path");
 function ensurePython(workspaceRoot) {
   const hasPython = runShell("python3", ["--version"], workspaceRoot) === 0 || runShell("python", ["--version"], workspaceRoot) === 0;
   if (!hasPython) {
@@ -658,7 +763,7 @@ pytest
 pip-audit
 `;
 function ensureRequirementsDev(workspaceRoot) {
-  const requirementsDevPath = (0, import_node_path6.join)(workspaceRoot, "requirements-dev.txt");
+  const requirementsDevPath = (0, import_node_path7.join)(workspaceRoot, "requirements-dev.txt");
   if (!fileExists(requirementsDevPath)) {
     writeFileEnsured(requirementsDevPath, PYTHON_REQUIREMENTS_DEV);
   }
@@ -666,11 +771,34 @@ function ensureRequirementsDev(workspaceRoot) {
 function pythonModuleDirectory(name) {
   return name.replaceAll("-", "_");
 }
-function addProjectJsonTargets2(projectJsonPath, newTargets) {
+function addProjectJsonTargets3(projectJsonPath, newTargets) {
   const project = readJson(projectJsonPath);
   const targets = project.targets ?? {};
   writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
 }
+function pythonAppMain(name) {
+  return `def main() -> None:
+    print('${name} is running')
+
+
+if __name__ == '__main__':
+    main()
+`;
+}
+function pythonAppStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    continuous: true,
+    options: { command: "python3 main.py", cwd: `apps/${name}` }
+  };
+}
+function pythonFunctionAppStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    continuous: true,
+    options: { command: "func start", cwd: `apps/${name}` }
+  };
+}
 function pythonAppPackageTarget(name) {
   const zip = `dist/drop/python-app-${name}.zip`;
   const command = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});const A=require('adm-zip');const z=new A();z.addLocalFolder('apps/${name}/dist');z.writeZip('${zip}')"`;
@@ -702,9 +830,12 @@ function addPythonApp(workspaceRoot, name) {
     ["g", "@mnci/nx-python-pip:application", name, `--directory=apps/${name}`, "--no-interactive"],
     workspaceRoot
   );
-  addProjectJsonTargets2((0, import_node_path6.join)(workspaceRoot, "apps", name, "project.json"), {
-    package: pythonAppPackageTarget(name)
+  writeFileEnsured((0, import_node_path7.join)(workspaceRoot, "apps", name, "main.py"), pythonAppMain(name));
+  addProjectJsonTargets3((0, import_node_path7.join)(workspaceRoot, "apps", name, "project.json"), {
+    package: pythonAppPackageTarget(name),
+    start: pythonAppStartTarget(name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 function addPythonFunctionApp(workspaceRoot, name) {
   ensurePython(workspaceRoot);
@@ -722,9 +853,11 @@ function addPythonFunctionApp(workspaceRoot, name) {
     workspaceRoot
   );
   const moduleDirectory = pythonModuleDirectory(name);
-  addProjectJsonTargets2((0, import_node_path6.join)(workspaceRoot, "apps", name, "project.json"), {
-    package: pythonFunctionAppPackageTarget(name, moduleDirectory)
+  addProjectJsonTargets3((0, import_node_path7.join)(workspaceRoot, "apps", name, "project.json"), {
+    package: pythonFunctionAppPackageTarget(name, moduleDirectory),
+    start: pythonFunctionAppStartTarget(name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: false, start: `nx run ${name}:start` });
 }
 function addPythonLib(workspaceRoot, name) {
   ensurePython(workspaceRoot);
@@ -740,6 +873,7 @@ function addPythonLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  registerProjectCommands(workspaceRoot, name, { build: true });
 }
 function addPythonInternalLib(workspaceRoot, name) {
   ensurePython(workspaceRoot);
@@ -755,11 +889,12 @@ function addPythonInternalLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  registerProjectCommands(workspaceRoot, name, { build: false });
 }
 var PYTHON_PROJECT_DIRS = ["apps", "python-packages", "libs"];
 function findPythonProjectDirectory(workspaceRoot, name) {
   return PYTHON_PROJECT_DIRS.find(
-    (directory) => fileExists((0, import_node_path6.join)(workspaceRoot, directory, name, "pyproject.toml"))
+    (directory) => fileExists((0, import_node_path7.join)(workspaceRoot, directory, name, "pyproject.toml"))
   );
 }
 function parseVendorEntries(pyprojectToml) {
@@ -798,7 +933,7 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
       `No Python project named '${consumer}' with a pyproject.toml found (checked apps/, python-packages/, libs/). A Python function app has no pyproject.toml \u2014 there is nothing to vendor into.`
     );
   }
-  if (!fileExists((0, import_node_path6.join)(workspaceRoot, "libs", lib, "pyproject.toml"))) {
+  if (!fileExists((0, import_node_path7.join)(workspaceRoot, "libs", lib, "pyproject.toml"))) {
     throw new Error(
       `No internal Python library named '${lib}' found at libs/${lib}/pyproject.toml. Only an internal library (added via 'mnci add python-internal-lib') can be vendored.`
     );
@@ -806,8 +941,8 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
   if (consumerDirectory === "libs" && consumer === lib) {
     throw new Error(`'${consumer}' cannot vendor itself.`);
   }
-  const pyprojectPath = (0, import_node_path6.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
-  const pyprojectToml = (0, import_node_fs3.readFileSync)(pyprojectPath, "utf8");
+  const pyprojectPath = (0, import_node_path7.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
+  const pyprojectToml = (0, import_node_fs4.readFileSync)(pyprojectPath, "utf8");
   if (parseVendorEntries(pyprojectToml).includes(lib)) {
     logger.info(`'${consumer}' already vendors '${lib}' \u2014 nothing to do.`);
     return;
@@ -819,8 +954,8 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
 }
 
 // src/commands/add/reactApp.ts
-var import_node_fs4 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path8 = require("path");
 function ensurePlugin2(workspaceRoot, packageName) {
   if (hasPlugin(workspaceRoot, packageName)) {
     return;
@@ -866,12 +1001,12 @@ function reactAppTargets(name) {
   return targets;
 }
 function allowEnvFiles(workspaceRoot) {
-  const gitignorePath = (0, import_node_path7.join)(workspaceRoot, ".gitignore");
+  const gitignorePath = (0, import_node_path8.join)(workspaceRoot, ".gitignore");
   if (!fileExists(gitignorePath)) {
     return;
   }
   const marker = "# MoNecromanCI: keep the committed per-environment Vite config (public VITE_ values)";
-  const current = (0, import_node_fs4.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs5.readFileSync)(gitignorePath, "utf8");
   if (current.includes(marker)) {
     return;
   }
@@ -898,12 +1033,13 @@ function addReactApp(workspaceRoot, name, stack) {
     workspaceRoot
   );
   ensureAdmZip(workspaceRoot);
-  const reactAppRoot = (0, import_node_path7.join)(workspaceRoot, "apps", name);
+  const reactAppRoot = (0, import_node_path8.join)(workspaceRoot, "apps", name);
   for (const environment of REACT_ENVIRONMENTS) {
-    writeFileEnsured((0, import_node_path7.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
+    writeFileEnsured((0, import_node_path8.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
   }
   allowEnvFiles(workspaceRoot);
-  addNxTargets((0, import_node_path7.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+  addNxTargets((0, import_node_path8.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:serve` });
 }
 
 // src/commands/add.ts
@@ -928,7 +1064,7 @@ var PROJECT_KINDS = [
 ];
 async function runAdd(kind, name, options) {
   const workspaceRoot = process.cwd();
-  if (!fileExists((0, import_node_path8.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path9.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `add` from the workspace root.");
   }
   const stack = readWorkspaceStack(workspaceRoot);
@@ -969,7 +1105,8 @@ async function runAdd(kind, name, options) {
         ],
         workspaceRoot
       );
-      markPrivate((0, import_node_path8.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      markPrivate((0, import_node_path9.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      registerProjectCommands(workspaceRoot, resolvedName, { build: true });
       break;
     }
     case "python-app": {
@@ -1041,7 +1178,7 @@ function syncProjectReferences(workspaceRoot) {
 }
 function readWorkspaceStack(workspaceRoot) {
   const nxJson = readJson(
-    (0, import_node_path8.join)(workspaceRoot, "nx.json")
+    (0, import_node_path9.join)(workspaceRoot, "nx.json")
   );
   const stack = nxJson.mnci?.stack;
   return {
@@ -1054,14 +1191,14 @@ function markPrivate(manifestPath) {
 }
 
 // src/commands/interactive.ts
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 var import_prompts7 = require("@inquirer/prompts");
 
 // src/commands/new.ts
-var import_node_path10 = require("path");
+var import_node_path11 = require("path");
 
 // src/overlay.ts
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 var DEFAULT_STACK = { testRunner: "jest" };
 var PRETTIER_VERSION = "^3.8.1";
 var TS_COMPILER_DEPENDENCIES = {
@@ -1155,12 +1292,7 @@ package-lock.json
 function vscodeWorkspace(workspaceName) {
   return JSON.stringify(
     {
-      folders: [
-        { path: ".", name: workspaceName },
-        { path: "packages/cli", name: "@mnci/cli" },
-        { path: "packages/nx-python-pip", name: "@mnci/nx-python-pip" },
-        { path: "libs/monecromanci-v2", name: "@mnci/monecromanci" }
-      ],
+      folders: [{ path: ".", name: workspaceName }],
       settings: {
         "eslint.validate": [
           "javascript",
@@ -1194,7 +1326,8 @@ function vscodeWorkspace(workspaceName) {
           "nrwl.angular-console",
           "firsttris.vscode-jest-runner"
         ]
-      }
+      },
+      tasks: { version: "2.0.0", tasks: [] }
     },
     null,
     2
@@ -1239,7 +1372,7 @@ function mnciConfig(options) {
   };
 }
 function readMnciConfig(workspaceRoot) {
-  const nxJson = readJson((0, import_node_path9.join)(workspaceRoot, "nx.json"));
+  const nxJson = readJson((0, import_node_path10.join)(workspaceRoot, "nx.json"));
   return nxJson.mnci ?? {};
 }
 function pythonPublishUrl(registry) {
@@ -1665,7 +1798,7 @@ updates:
       interval: weekly
 `;
 function applyOverlay(workspaceRoot, options) {
-  const nxJsonPath = (0, import_node_path9.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path10.join)(workspaceRoot, "nx.json");
   const nxJson = readJson(nxJsonPath);
   const generators = {
     ...nxJson.generators,
@@ -1677,7 +1810,7 @@ function applyOverlay(workspaceRoot, options) {
     nxJsonPath,
     toJson({ ...withReleaseConfig(nxJson, options.ci), generators, sync, mnci })
   );
-  const manifestPath = (0, import_node_path9.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path10.join)(workspaceRoot, "package.json");
   const manifest = readJson(manifestPath);
   const scripts = {
     ...manifest.scripts,
@@ -1692,30 +1825,30 @@ function applyOverlay(workspaceRoot, options) {
     manifestPath,
     toJson({ ...manifest, name: `${options.scope}/source`, scripts, devDependencies: devDeps })
   );
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".npmrc"), npmrcContent(options.registry, options.scope));
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, "commitlint.config.mjs"), COMMITLINT_CONFIG);
-  const hookPath = (0, import_node_path9.join)(workspaceRoot, ".husky/commit-msg");
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, ".npmrc"), npmrcContent(options.registry, options.scope));
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, "commitlint.config.mjs"), COMMITLINT_CONFIG);
+  const hookPath = (0, import_node_path10.join)(workspaceRoot, ".husky/commit-msg");
   writeFileEnsured(hookPath, COMMIT_MSG_HOOK);
   markExecutable(hookPath);
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".prettierrc.json"), PRETTIER_CONFIG);
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".prettierignore"), PRETTIER_IGNORE);
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, ".prettierrc.json"), PRETTIER_CONFIG);
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, ".prettierignore"), PRETTIER_IGNORE);
   writeFileEnsured(
-    (0, import_node_path9.join)(workspaceRoot, `${options.workspaceName}.code-workspace`),
+    (0, import_node_path10.join)(workspaceRoot, `${options.workspaceName}.code-workspace`),
     vscodeWorkspace(options.workspaceName)
   );
   const publishUrl = pythonPublishUrl(options.registry);
   if (options.ci === "azure" || options.ci === "both") {
     writeFileEnsured(
-      (0, import_node_path9.join)(workspaceRoot, "azure-pipelines.yml"),
+      (0, import_node_path10.join)(workspaceRoot, "azure-pipelines.yml"),
       azurePipelinesYaml(options.agent, options.variableGroup, publishUrl, options.registry.kind)
     );
   }
   if (options.ci === "github" || options.ci === "both") {
     writeFileEnsured(
-      (0, import_node_path9.join)(workspaceRoot, ".github/workflows/ci.yml"),
+      (0, import_node_path10.join)(workspaceRoot, ".github/workflows/ci.yml"),
       githubActionsYaml(options.agent, publishUrl, options.registry.kind, options.ci)
     );
-    writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".github/dependabot.yml"), DEPENDABOT_CONFIG);
+    writeFileEnsured((0, import_node_path10.join)(workspaceRoot, ".github/dependabot.yml"), DEPENDABOT_CONFIG);
   }
 }
 
@@ -1784,7 +1917,7 @@ async function runNew(name, options) {
     ],
     process.cwd()
   );
-  const workspaceRoot = (0, import_node_path10.join)(process.cwd(), workspaceName);
+  const workspaceRoot = (0, import_node_path11.join)(process.cwd(), workspaceName);
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
   );
@@ -1817,7 +1950,7 @@ async function runNew(name, options) {
 }
 
 // src/commands/upgrade.ts
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 function resolveRegistry2(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
     const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
@@ -1869,7 +2002,7 @@ function resolveOverlayOptions(options, persisted) {
   return { scope, registry, agent, variableGroup, ci, stack: { testRunner } };
 }
 function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path11.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path12.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.`
     );
@@ -1885,7 +2018,7 @@ function runUpgrade(workspaceRoot, options) {
 
 // src/commands/interactive.ts
 async function runInteractive() {
-  const inWorkspace = fileExists((0, import_node_path12.join)(process.cwd(), "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path13.join)(process.cwd(), "nx.json"));
   const newChoice = { name: "Create a new monorepo", value: "new" };
   const addChoice = { name: "Add a project to this workspace", value: "add" };
   const upgradeChoice = {
@@ -1906,8 +2039,8 @@ async function runInteractive() {
 }
 
 // src/util/versionChecker.ts
-var import_node_fs5 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path14 = require("path");
 var import_cross_spawn2 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
@@ -1963,8 +2096,8 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path13.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs5.readFileSync)(manifestPath, "utf8"));
+    const manifestPath = (0, import_node_path14.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs6.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";