@mnci/cli 1.9.0 → 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,11 +164,11 @@ function assertValidProjectName(name, label) {
   }
 }
 
-// src/commands/add/go.ts
-var import_node_fs2 = require("fs");
+// 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"));
@@ -202,8 +202,126 @@ 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(
+      "Flutter not found. Install the Flutter SDK first (3.27+, for Dart 3.6+ pub workspaces): https://docs.flutter.dev/get-started/install"
+    );
+  }
+}
+function nxFlutterPluginSpec() {
+  return process.env.MNCI_NX_FLUTTER_SPEC ?? "@mnci/nx-flutter";
+}
+function ensureNxFlutterPlugin(workspaceRoot) {
+  if (hasPlugin(workspaceRoot, "@mnci/nx-flutter")) {
+    return;
+  }
+  const spec = nxFlutterPluginSpec();
+  logger.step(`Installing the Flutter toolchain plugin (${spec})`);
+  if (runShell("npm", ["install", "--save-dev", spec, "--no-audit", "--no-fund"], workspaceRoot) !== 0) {
+    throw new Error("npm install of @mnci/nx-flutter failed");
+  }
+}
+function prepareFlutter(workspaceRoot) {
+  ensureFlutter(workspaceRoot);
+  ensureNxFlutterPlugin(workspaceRoot);
+}
+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_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/");
@@ -230,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)");
@@ -239,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 } }));
@@ -275,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);
@@ -295,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);
@@ -316,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);
@@ -336,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}`);
@@ -358,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}`);
@@ -369,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;
@@ -408,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")) {
@@ -461,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}` }
     })
   );
@@ -479,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"],
@@ -488,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';
@@ -539,6 +680,17 @@ export default [
           ignoredFiles: [
             '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
             '{projectRoot}/rollup.config.{js,ts,mjs,mts,cjs,cts}',
+            // Same reasoning as the two config files above, extended to the test
+            // toolchain: rollup bundles from the entry point only, so neither the
+            // Vitest config nor the spec files reach the published package \u2014 their
+            // imports must not drive the published manifest.
+            //
+            // Without this, a vitest-stack workspace fails \`npm run lint\` on a
+            // freshly generated npm-lib: Nx's own spec imports \`vitest\`, and
+            // @nx/dependency-checks then demands it be declared as a runtime
+            // dependency of a package that never uses it at runtime.
+            '{projectRoot}/vitest.config.{js,ts,mjs,mts,cjs,cts}',
+            '{projectRoot}/**/*.spec.{js,ts,jsx,tsx}',
           ],
         },
       ],
@@ -568,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);
@@ -580,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) {
@@ -610,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);
   }
@@ -618,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}')"`;
@@ -654,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);
@@ -674,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);
@@ -692,6 +873,7 @@ function addPythonLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  registerProjectCommands(workspaceRoot, name, { build: true });
 }
 function addPythonInternalLib(workspaceRoot, name) {
   ensurePython(workspaceRoot);
@@ -707,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) {
@@ -750,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.`
     );
@@ -758,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;
@@ -771,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;
@@ -818,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;
   }
@@ -850,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
@@ -873,11 +1057,14 @@ var PROJECT_KINDS = [
   "go-app",
   "go-function-app",
   "go-lib",
-  "go-internal-lib"
+  "go-internal-lib",
+  "flutter-app",
+  "flutter-lib",
+  "flutter-internal-lib"
 ];
 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);
@@ -918,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": {
@@ -953,6 +1141,18 @@ async function runAdd(kind, name, options) {
       addGoInternalLib(workspaceRoot, resolvedName);
       break;
     }
+    case "flutter-app": {
+      addFlutterApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "flutter-lib": {
+      addFlutterLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "flutter-internal-lib": {
+      addFlutterInternalLib(workspaceRoot, resolvedName);
+      break;
+    }
     case "python-vendor": {
       await addPythonVendor(workspaceRoot, resolvedName, options, kindProvided);
       syncProjectReferences(workspaceRoot);
@@ -978,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 {
@@ -991,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 = {
@@ -1038,7 +1238,7 @@ function releaseConfig(ci) {
   const githubReleases = ci === "github";
   return {
     projectsRelationship: "independent",
-    projects: ["packages/*", "python-packages/*"],
+    projects: ["packages/*", "python-packages/*", "!tag:type:go-lib"],
     releaseTag: { pattern: "{projectName}@{version}" },
     git: { commit: false, tag: true, push: githubReleases },
     version: {
@@ -1092,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",
@@ -1131,7 +1326,8 @@ function vscodeWorkspace(workspaceName) {
           "nrwl.angular-console",
           "firsttris.vscode-jest-runner"
         ]
-      }
+      },
+      tasks: { version: "2.0.0", tasks: [] }
     },
     null,
     2
@@ -1176,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) {
@@ -1193,6 +1389,13 @@ var GOLANGCI_LINT_INSTALL_GUARD = `node -e "const fs=require('node:fs'),cp=requi
 var GO_TOOL_PATH_PRELUDE = `const fs=require('node:fs'),cp=require('node:child_process');if(!fs.existsSync('go.mod')){console.log('No Go projects - skipping.');process.exit(0)}const r=cp.spawnSync('go',['env','GOPATH'],{encoding:'utf8'});if(r.status!==0){console.log('Could not resolve GOPATH - skipping.');process.exit(0)}const bin=require('node:path').join(r.stdout.trim(),'bin');`;
 var GO_TOOL_PATH_AZURE = `node -e "${GO_TOOL_PATH_PRELUDE}console.log('##vso[task.prependpath]'+bin)"`;
 var GO_TOOL_PATH_GITHUB = `node -e "${GO_TOOL_PATH_PRELUDE}if(!process.env.GITHUB_PATH){console.log('Not running in GitHub Actions - skipping.');process.exit(0)}fs.appendFileSync(process.env.GITHUB_PATH,bin+${String.raw`'\n'`})"`;
+var FLUTTER_SDK_VERSION = "3.44.8";
+var FLUTTER_SDK_DIRECTORY_EXPRESSION = `require('node:path').join(require('node:os').homedir(),'.mnci-flutter-${FLUTTER_SDK_VERSION}')`;
+var FLUTTER_SDK_INSTALL_GUARD = `node -e "const fs=require('node:fs'),cp=require('node:child_process');if(!fs.existsSync('pubspec.yaml')){console.log('No Flutter projects - skipping.');process.exit(0)}if(cp.spawnSync('flutter',['--version'],{stdio:'ignore',shell:process.platform==='win32'}).status===0){console.log('Flutter SDK already on PATH - skipping.');process.exit(0)}const sdk=${FLUTTER_SDK_DIRECTORY_EXPRESSION};if(fs.existsSync(sdk)){console.log('Flutter SDK already installed at '+sdk+' - skipping.');process.exit(0)}process.exit(cp.spawnSync('git',['clone','--depth','1','--branch','${FLUTTER_SDK_VERSION}','https://github.com/flutter/flutter.git',sdk],{stdio:'inherit'}).status ?? 1)"`;
+var FLUTTER_TOOL_PATH_PRELUDE = `const fs=require('node:fs'),path=require('node:path');if(!fs.existsSync('pubspec.yaml')){console.log('No Flutter projects - skipping.');process.exit(0)}const sdk=${FLUTTER_SDK_DIRECTORY_EXPRESSION};if(!fs.existsSync(sdk)){console.log('Flutter SDK was not installed by mnci (already on PATH) - skipping.');process.exit(0)}const bin=path.join(sdk,'bin');`;
+var FLUTTER_TOOL_PATH_AZURE = `node -e "${FLUTTER_TOOL_PATH_PRELUDE}console.log('##vso[task.prependpath]'+bin)"`;
+var FLUTTER_TOOL_PATH_GITHUB = `node -e "${FLUTTER_TOOL_PATH_PRELUDE}if(!process.env.GITHUB_PATH){console.log('Not running in GitHub Actions - skipping.');process.exit(0)}fs.appendFileSync(process.env.GITHUB_PATH,bin+${String.raw`'\n'`})"`;
+var FLUTTER_PUB_GET_GUARD = `node -e "const fs=require('node:fs');if(!fs.existsSync('pubspec.yaml')){console.log('No Flutter projects - skipping.');process.exit(0)}process.exit(require('node:child_process').spawnSync('flutter',['pub','get'],{stdio:'inherit',shell:process.platform==='win32'}).status ?? 1)"`;
 var NPM_AUDIT_STEP = "npm audit --audit-level=high || echo npm audit found vulnerabilities, see log above - non-blocking, run npm audit locally to inspect";
 var PACK_APPS_GUARD = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});if(fs.globSync('apps/*/project.json').length===0){console.log('No apps to pack - skipping.');process.exit(0)}process.exit(require('node:child_process').spawnSync('npx nx run-many -t package',{stdio:'inherit',shell:true}).status ?? 1)"`;
 function releaseGuard(pythonPublishEnv) {
@@ -1308,6 +1511,23 @@ steps:
   - script: ${GO_TOOL_PATH_AZURE}
     displayName: Add Go tool bin to PATH
 
+  # Flutter, if the workspace has any. Unlike Python and Go, hosted agents do
+  # NOT ship the Flutter SDK, so this installs it (shallow git clone at a
+  # pinned tag) and puts it on PATH. All three guards skip cleanly on a
+  # workspace with no root pubspec.yaml, and the install also skips when an
+  # SDK is already on PATH.
+  - script: ${FLUTTER_SDK_INSTALL_GUARD}
+    displayName: Install the Flutter SDK (${FLUTTER_SDK_VERSION})
+
+  - script: ${FLUTTER_TOOL_PATH_AZURE}
+    displayName: Add the Flutter SDK to PATH
+
+  # One command resolves EVERY Dart dependency, internal and external, for the
+  # whole workspace: the projects are pub workspace members, so this writes a
+  # single root pubspec.lock they all share.
+  - script: ${FLUTTER_PUB_GET_GUARD}
+    displayName: Resolve Dart dependencies (one pub get for the whole workspace)
+
   # Fails fast, with an unambiguous message, when a stale TypeScript project
   # reference (or another sync generator's drift) was never synced+committed
   # locally \u2014 sync.applyChanges (nx.json) only auto-applies interactively, so
@@ -1462,6 +1682,23 @@ jobs:
       - run: ${GO_TOOL_PATH_GITHUB}
         name: Add Go tool bin to PATH
 
+      # Flutter, if the workspace has any. Unlike Python and Go, hosted runners
+      # do NOT ship the Flutter SDK, so this installs it (shallow git clone at
+      # a pinned tag) and puts it on PATH. All three guards skip cleanly on a
+      # workspace with no root pubspec.yaml, and the install also skips when an
+      # SDK is already on PATH.
+      - run: ${FLUTTER_SDK_INSTALL_GUARD}
+        name: Install the Flutter SDK (${FLUTTER_SDK_VERSION})
+
+      - run: ${FLUTTER_TOOL_PATH_GITHUB}
+        name: Add the Flutter SDK to PATH
+
+      # One command resolves EVERY Dart dependency, internal and external, for
+      # the whole workspace: the projects are pub workspace members, so this
+      # writes a single root pubspec.lock they all share.
+      - run: ${FLUTTER_PUB_GET_GUARD}
+        name: Resolve Dart dependencies (one pub get for the whole workspace)
+
       # Fails fast, with an unambiguous message, when a stale TypeScript project
       # reference (or another sync generator's drift) was never synced+committed
       # locally \u2014 sync.applyChanges (nx.json) only auto-applies interactively, so
@@ -1547,9 +1784,21 @@ updates:
       - "/libs/*"
     schedule:
       interval: weekly
+
+  # Same glob reasoning as pip above. Dart projects are pub workspace members,
+  # so each one declares its own dependencies even though they all resolve
+  # through the single root pubspec.lock \u2014 hence the per-project directories
+  # rather than just "/".
+  - package-ecosystem: pub
+    directories:
+      - "/apps/*"
+      - "/packages/*"
+      - "/libs/*"
+    schedule:
+      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,
@@ -1561,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,
@@ -1576,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);
   }
 }
 
@@ -1668,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)"
   );
@@ -1689,13 +1938,19 @@ async function runNew(name, options) {
     "  mnci add react-app web        # or: node-app, node-function-app, npm-lib, internal-lib,"
   );
   logger.info(
-    "                                 #     python-app, python-function-app, python-lib, python-internal-lib"
+    "                                 #     python-app, python-function-app, python-lib, python-internal-lib,"
+  );
+  logger.info(
+    "                                 #     go-app, go-function-app, go-lib, go-internal-lib,"
+  );
+  logger.info(
+    "                                 #     flutter-app, flutter-lib, flutter-internal-lib"
   );
   logger.info('  git add -A && git commit -m "feat: initial workspace"');
 }
 
 // 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;
@@ -1747,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.`
     );
@@ -1763,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 = {
@@ -1784,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;
@@ -1841,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";