@vnejs/monorepo 0.0.5 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/monorepo",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Monorepo tooling for @vnejs",
   "main": "src/index.js",
   "bin": {
@@ -16,6 +16,8 @@
   "license": "ISC",
   "dependencies": {
     "commander": "~15.0.0",
-    "typescript": "6.0.3"
+    "happy-dom": "~20.0.0",
+    "typescript": "6.0.3",
+    "vitest": "~3.2.4"
   }
 }

package/src/bump/index.js

@@ -3,6 +3,8 @@ const listWorkspacePackages = require("../workspace/list-packages");
 const syncDeps = require("../sync-deps");
 const runChanged = require("../run-changed");
 const { run } = require("../publish/utils");
+const confirm = require("../utils/confirm");
+const { formatPackageLine } = require("../utils/format-package");
 
 const PHASES = ["graph", "sync-all", "patch"];
 
@@ -27,9 +29,45 @@ const previousMinorLine = (version) => {
   process.exit(1);
 };
 
-module.exports = (version, options = {}) => {
+const describeBumpPlan = (version, options, phases) => {
+  const expectVersion = options.expectVersion ?? version;
+  const onlyVersion = options.onlyVersion ?? previousMinorLine(version);
+  const lines = [`\nBump target: ${expectVersion}.x`];
+
+  if (phases.includes("graph")) {
+    const { order } = resolveGraph({
+      cwd: options.cwd,
+      onlyVersion,
+      script: "publish:minor",
+    });
+
+    if (!order.length) {
+      console.error("No packages matched graph filters for phase 1.");
+      process.exit(1);
+    }
+
+    lines.push(`Phase 1: sync-deps + publish:minor (${order.length} packages, filter ${onlyVersion}.x)`);
+  }
+
+  if (phases.includes("sync-all")) {
+    const { packages } = listWorkspacePackages({ cwd: options.cwd });
+    lines.push(`Phase 2: sync-deps --all (${packages.length} packages)`);
+  }
+
+  if (phases.includes("patch")) {
+    lines.push(`Phase 3: publish:patch changed packages (ref ${options.ref ?? "HEAD"})`);
+  }
+
+  if (options.dryRun) {
+    lines.push("\nMode: dry run");
+  }
+
+  return lines.join("\n");
+};
+
+module.exports = async (version, options = {}) => {
   const dryRun = Boolean(options.dryRun);
-  const phases = options.phase ? [options.phase] : ["graph", "sync-all", "patch"];
+  const phases = options.phase ? [options.phase] : PHASES;
 
   if (options.phase && !PHASES.includes(options.phase)) {
     console.error(`phase must be one of: ${PHASES.join(", ")}`);
@@ -41,6 +79,17 @@ module.exports = (version, options = {}) => {
   const expectVersion = options.expectVersion ?? version;
   const onlyVersion = options.onlyVersion ?? previousMinorLine(version);
 
+  console.log(describeBumpPlan(version, { ...options, expectVersion, onlyVersion }, phases));
+
+  if (!dryRun) {
+    const confirmed = await confirm("Continue? [y/N] ");
+
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+
   const graphOptions = {
     cwd: options.cwd,
     onlyVersion,
@@ -66,7 +115,7 @@ module.exports = (version, options = {}) => {
     }
 
     order.forEach((pkg, index) => {
-      console.log(`\n==> [${index + 1}/${order.length}] ${pkg.name} (${pkg.dir})`);
+      console.log(formatPackageLine(pkg, { leadingNewline: true, tag: `[${index + 1}/${order.length}]` }));
 
       if (dryRun) {
         console.log(`  sync-deps --expect-version ${syncOptions.expectVersion}`);
@@ -96,7 +145,8 @@ module.exports = (version, options = {}) => {
   if (phases.includes("patch")) {
     console.log(`\n=== Phase 3: publish:changed:patch ===`);
 
-    runChanged("publish:patch", {
+    await runChanged({
+      script: "publish:patch",
       ref: options.ref ?? "HEAD",
       dryRun,
     });

package/src/changed-packages.js

@@ -3,6 +3,7 @@ const { existsSync } = require("fs");
 const path = require("path");
 const readPackageJson = require("./workspace/read-package-json");
 const findMonorepoRoot = require("./workspace/find-root");
+const isStubTestScript = require("./workspace/is-stub-test-script");
 
 const getChangedFiles = (root, ref = "HEAD") => {
   const files = new Set();
@@ -30,7 +31,7 @@ const findPackageForFile = (root, filePath) => {
       const pkg = readPackageJson(dir);
       if (dir === root) return null;
 
-      return { name: pkg.name, dir: path.relative(root, dir) || "." };
+      return { name: pkg.name, version: pkg.version ?? "0.0.0", dir: path.relative(root, dir) || "." };
     }
 
     if (dir === root) break;
@@ -54,7 +55,12 @@ const getChangedPackages = (options = {}) => {
   if (options.script) {
     result = result.filter((pkg) => {
       const pkgJson = readPackageJson(path.join(root, pkg.dir));
-      return Boolean(pkgJson.scripts?.[options.script]);
+      const script = pkgJson.scripts?.[options.script];
+
+      if (!script) return false;
+      if (options.script === "test" && isStubTestScript(script)) return false;
+
+      return true;
     });
   }
 

package/src/cli.js

@@ -4,12 +4,11 @@ const { Command } = require("commander");
 
 const packageJson = require("../package.json");
 const publishAction = require("./publish");
-const { getChangedPackages } = require("./changed-packages");
 const runChangedAction = require("./run-changed");
 const graphAction = require("./graph");
 const syncDepsAction = require("./sync-deps");
 const bumpAction = require("./bump");
-const buildAction = require("./build");
+const runAction = require("./run");
 const clearAction = require("./clear");
 
 const program = new Command();
@@ -39,7 +38,7 @@ program
   .option("--only-version <pattern>", "filter by version prefix, e.g. 0.0.x")
   .option("--name <pattern>", "filter by package name substring")
   .option("--script <script>", "only packages that define this npm script")
-  .option("--layers", "group packages into parallel publish layers", false)
+  .option("--flat", "show packages as a flat list with layer column", false)
   .option("--format <format>", "output format: text | json", "text")
   .action(graphAction);
 
@@ -67,7 +66,7 @@ program
   .option("--dry-run", "show planned steps without making changes", false)
   .option("--only-version <pattern>", "graph version filter for phase 1 (default: previous minor line)")
   .option("--phase <phase>", "run only one phase: graph | sync-all | patch")
-  .option("--ref <ref>", "git ref for phase 3 changed-packages", "HEAD")
+  .option("--ref <ref>", "git ref for phase 3 run-changed", "HEAD")
   .option("--workspace", "use workspace versions in sync-deps (phase 2)", false)
   .option("--expect-version <version>", "wait until npm has this major.minor line (default: <version>)")
   .option("--expect-wait <ms>", "delay between npm retries", "10000")
@@ -81,37 +80,28 @@ program
   );
 
 program
-  .command("build")
-  .description("Build workspace packages in dependency order (turbo per layer)")
+  .command("test")
+  .description("run vitest in current directory")
+  .action((options) => require("./test")(options));
+
+program
+  .command("run")
+  .description("Run an npm script in workspace packages in dependency order (turbo per layer)")
   .option("--script <script>", "npm script to run in each package", "build")
   .option("--only-version <pattern>", "filter by version prefix, e.g. 0.0.x")
   .option("--name <pattern>", "filter by package name substring (includes dependency closure)")
-  .option("--sequential", "build one package at a time in flat graph order", false)
+  .option("-s, --sequential", "run one package at a time in flat graph order (stdio inherit, no turbo parallelism)", false)
   .option("--force", "pass --force to turbo (bypass cache)", false)
-  .option("--dry-run", "show build plan without running", false)
-  .action((options) => buildAction(options));
-
-program
-  .command("changed-packages")
-  .description("List workspace packages changed in git")
-  .option("--ref <ref>", "git ref to compare against", "HEAD")
-  .option("--script <script>", "only packages that define this npm script")
-  .action((options) => {
-    const { packages } = getChangedPackages({ ref: options.ref, script: options.script });
-
-    packages.forEach((pkg, index) => {
-      console.log(`==> [${index + 1}/${packages.length}] ${pkg.name} (${pkg.dir})`);
-    });
-    console.log("");
-    console.log(`Total: ${packages.length}`);
-  });
+  .option("--dry-run", "show run plan without executing", false)
+  .action((options) => runAction(options));
 
 program
   .command("run-changed")
   .description("Run npm script sequentially in git-changed workspace packages")
-  .argument("<script>", "npm script name from package.json")
+  .option("--script <script>", "npm script name from package.json")
   .option("--ref <ref>", "git ref to compare against", "HEAD")
-  .option("--dry-run", "list packages without running the script", false)
+  .option("--dry-run", "list changed packages without running the script", false)
+  .option("--confirm", "ask for confirmation before running the script", false)
   .action(runChangedAction);
 
 program

package/src/graph/index.js

@@ -1,5 +1,30 @@
 const path = require("path");
 const resolveGraph = require("../workspace/resolve-graph");
+const { formatPackageLine, formatPackageRef } = require("../utils/format-package");
+
+const buildLayerMeta = (layers) => {
+  const byName = new Map();
+
+  layers.forEach((layer, layerIndex) => {
+    layer.forEach((pkg, packageIndex) => {
+      byName.set(pkg.name, {
+        layer: layerIndex + 1,
+        layerTotal: layers.length,
+        layerIndex: packageIndex + 1,
+        layerSize: layer.length,
+      });
+    });
+  });
+
+  return byName;
+};
+
+const toPackageEntry = (pkg, meta) => ({
+  name: pkg.name,
+  version: pkg.version,
+  dir: pkg.dir,
+  ...meta,
+});
 
 module.exports = (options = {}) => {
   const { root, order, layers } = resolveGraph(options);
@@ -9,16 +34,26 @@ module.exports = (options = {}) => {
     return { root, packages: [], layers: [], order: [] };
   }
 
+  const layerMetaByName = buildLayerMeta(layers);
+
   if (options.format === "json") {
     console.log(
       JSON.stringify(
         {
           root,
           total: order.length,
-          layers: layers.map((layer) =>
-            layer.map((pkg) => ({ name: pkg.name, version: pkg.version, dir: pkg.dir })),
+          layerTotal: layers.length,
+          layers: layers.map((layer, layerIndex) =>
+            layer.map((pkg, packageIndex) =>
+              toPackageEntry(pkg, {
+                layer: layerIndex + 1,
+                layerTotal: layers.length,
+                layerIndex: packageIndex + 1,
+                layerSize: layer.length,
+              }),
+            ),
           ),
-          order: order.map((pkg) => ({ name: pkg.name, version: pkg.version, dir: pkg.dir })),
+          order: order.map((pkg) => toPackageEntry(pkg, layerMetaByName.get(pkg.name))),
         },
         null,
         2,
@@ -28,26 +63,31 @@ module.exports = (options = {}) => {
     return { root, packages: order, layers, order: order.map((pkg) => pkg.name) };
   }
 
-  if (options.layers) {
-    layers.forEach((layer, index) => {
-      console.log(`# layer ${index + 1} (${layer.length})`);
+  console.log(`\n=== Graph: ${order.length} packages, ${layers.length} layers ===`);
+  console.log(`Root: ${path.relative(process.cwd(), root) || "."}\n`);
 
-      layer.forEach((pkg) => {
-        console.log(`${pkg.name}\t${pkg.version}\t${pkg.dir}`);
-      });
-
-      if (index < layers.length - 1) console.log("");
-    });
-  } else {
+  if (options.flat) {
     order.forEach((pkg, index) => {
-      console.log(`${index + 1}\t${pkg.name}\t${pkg.version}\t${pkg.dir}`);
+      const meta = layerMetaByName.get(pkg.name);
+      console.log(
+        `${index + 1}\t${meta.layer}/${meta.layerTotal}\t${formatPackageRef(pkg)}\t${pkg.dir}`,
+      );
     });
-  }
+  } else {
+    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
+      const layer = layers[layerIndex];
+      console.log(`\n=== Layer ${layerIndex + 1}/${layers.length} (${layer.length} packages) ===`);
 
-  console.log("");
-  console.log(`Root: ${path.relative(process.cwd(), root) || "."}`);
-  console.log(`Packages: ${order.length}`);
-  console.log(`Layers: ${layers.length}`);
+      layer.forEach((pkg, packageIndex) => {
+        console.log(
+          formatPackageLine(pkg, {
+            indent: "  ",
+            tag: `[${layerIndex + 1}/${layers.length}:${packageIndex + 1}/${layer.length}]`,
+          }),
+        );
+      });
+    }
+  }
 
   return {
     root,

package/src/index.js

@@ -1,12 +1,13 @@
 module.exports = {
   package: require("./package"),
+  test: require("./test"),
   publish: require("./publish"),
   getChangedPackages: require("./changed-packages").getChangedPackages,
   runChanged: require("./run-changed"),
   graph: require("./graph"),
   syncDeps: require("./sync-deps"),
   bump: require("./bump"),
-  build: require("./build"),
+  run: require("./run"),
   clear: require("./clear"),
   resolveGraph: require("./workspace/resolve-graph"),
   listWorkspacePackages: require("./workspace/list-packages"),

package/src/{build → run}/index.js

@@ -1,6 +1,7 @@
 const resolveGraph = require("../workspace/resolve-graph");
 const findRoot = require("../workspace/find-root");
 const { run } = require("../publish/utils");
+const { formatPackageLine } = require("../utils/format-package");
 
 const runLayerTurbo = (layer, root, { script, force }) => {
   const filters = layer.map((pkg) => `--filter=${pkg.name}`).join(" ");
@@ -28,13 +29,13 @@ module.exports = (options = {}) => {
     process.exit(1);
   }
 
-  console.log(`\n=== Build: ${order.length} packages, ${layers.length} layers ===`);
+  console.log(`\n=== Run: ${order.length} packages, ${layers.length} layers ===`);
   console.log(`Script: ${script}`);
   console.log(`Root: ${root}`);
   console.log(`Mode: ${sequential ? "sequential" : "layers (turbo)"}\n`);
 
   const runPackage = (pkg, label) => {
-    console.log(`\n==> ${label} ${pkg.name} (${pkg.dir})`);
+    console.log(formatPackageLine(pkg, { leadingNewline: true, tag: label }));
 
     if (dryRun) return;
 
@@ -51,7 +52,12 @@ module.exports = (options = {}) => {
       if (dryRun) {
         console.log(`  turbo run ${script} ${layer.map((pkg) => `--filter=${pkg.name}`).join(" ")}`);
         layer.forEach((pkg, index) => {
-          console.log(`  ==> [${layerIndex + 1}/${layers.length}:${index + 1}/${layer.length}] ${pkg.name} (${pkg.dir})`);
+          console.log(
+            formatPackageLine(pkg, {
+              indent: "  ",
+              tag: `[${layerIndex + 1}/${layers.length}:${index + 1}/${layer.length}]`,
+            }),
+          );
         });
         continue;
       }

package/src/run-changed/index.js

@@ -1,24 +1,70 @@
 const path = require("path");
 
 const { getChangedPackages } = require("../changed-packages");
+const resolveGraph = require("../workspace/resolve-graph");
 const { run } = require("../publish/utils");
+const confirm = require("../utils/confirm");
+const { formatPackageLine } = require("../utils/format-package");
 
-module.exports = (script, options = {}) => {
-  const { root, packages } = getChangedPackages({ ref: options.ref, script });
+const sortByGraphOrder = (root, changedPackages, script) => {
+  const changedNames = new Set(changedPackages.map((pkg) => pkg.name));
+  const { order } = resolveGraph({ cwd: root, script });
 
-  if (!packages.length) {
-    console.log(`No changed packages with script "${script}".`);
+  const sorted = order.filter((pkg) => changedNames.has(pkg.name));
+
+  const sortedNames = new Set(sorted.map((pkg) => pkg.name));
+  const rest = changedPackages.filter((pkg) => !sortedNames.has(pkg.name));
+
+  return [...sorted, ...rest];
+};
+
+const printPackages = (packages) => {
+  packages.forEach((pkg, index) => {
+    console.log(formatPackageLine(pkg, { tag: `[${index + 1}/${packages.length}]` }));
+  });
+  console.log("");
+  console.log(`Total: ${packages.length}`);
+};
+
+module.exports = async (options = {}) => {
+  const script = options.script;
+
+  if (!options.dryRun && !script) {
+    console.error('Missing required option "--script".');
+    process.exit(1);
+  }
+
+  const { root, packages: changedPackages } = getChangedPackages({ ref: options.ref, script });
+
+  if (!changedPackages.length) {
+    console.log(script ? `No changed packages with script "${script}".` : "No changed packages.");
     return;
   }
 
-  for (const [index, pkg] of packages.entries()) {
-    const pkgDir = path.join(root, pkg.dir);
-    console.log(`\n==> [${index + 1}/${packages.length}] ${pkg.name} (${pkg.dir})`);
+  const packages = sortByGraphOrder(root, changedPackages, script);
+
+  if (options.dryRun) {
+    printPackages(packages);
+    return;
+  }
 
-    if (options.dryRun) continue;
+  if (options.confirm) {
+    console.log(`\nThe following packages will run "${script}":\n`);
+    printPackages(packages);
 
-    run(`npm run ${script}`, pkgDir);
+    const confirmed = await confirm(`Continue? [y/N] `);
+
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+
+    console.log("");
   }
 
-  if (options.dryRun) console.log(`\nTotal: ${packages.length}`);
+  for (const [index, pkg] of packages.entries()) {
+    const pkgDir = path.join(root, pkg.dir);
+    console.log(formatPackageLine(pkg, { leadingNewline: true, tag: `[${index + 1}/${packages.length}]` }));
+    run(`npm run ${script}`, pkgDir);
+  }
 };

package/src/sync-deps/index.js

@@ -5,6 +5,7 @@ const listWorkspacePackages = require("../workspace/list-packages");
 const fetchNpmVersion = require("../workspace/fetch-npm-version");
 const toTildeMinor = require("../workspace/to-tilde-minor");
 const { DEPENDENCY_FIELDS } = require("../workspace/build-graph");
+const { formatPackageLine } = require("../utils/format-package");
 
 const resolveVersion = (name, options) => {
   if (options.workspace) {
@@ -102,7 +103,7 @@ module.exports = (options = {}) => {
     console.log(`Syncing dependencies in ${packages.length} workspace packages...`);
 
     for (const pkg of packages) {
-      console.log(`\n==> ${pkg.name} (${pkg.dir})`);
+      console.log(formatPackageLine(pkg, { leadingNewline: true }));
 
       if (options.dryRun) {
         console.log("  sync-deps");

package/src/test/index.js

@@ -0,0 +1,16 @@
+const { execSync } = require("child_process");
+const { existsSync } = require("fs");
+const path = require("path");
+
+module.exports = (options = {}) => {
+  const pkgDir = options.cwd || process.cwd();
+  const configPath = path.join(pkgDir, "vitest.config.js");
+
+  if (!existsSync(configPath)) {
+    console.error(`vitest.config.js not found: ${configPath}`);
+    process.exit(1);
+  }
+
+  const vitest = require.resolve("vitest/vitest.mjs");
+  execSync(`node "${vitest}" run`, { cwd: pkgDir, stdio: "inherit" });
+};

package/src/utils/confirm.js

@@ -0,0 +1,14 @@
+const readline = require("readline/promises");
+
+const confirm = async (message) => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    const answer = await rl.question(message);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+};
+
+module.exports = confirm;

package/src/utils/format-package.js

@@ -0,0 +1,13 @@
+const formatPackageRef = (pkg) => `${pkg.name}@${pkg.version ?? "0.0.0"}`;
+
+const formatPackageLine = (pkg, options = {}) => {
+  const { prefix = "==>", tag, indent = "", leadingNewline = false } = options;
+  const tagPart = tag ? `${tag} ` : "";
+
+  return `${leadingNewline ? "\n" : ""}${indent}${prefix} ${tagPart}${formatPackageRef(pkg)} (${pkg.dir})`;
+};
+
+module.exports = {
+  formatPackageRef,
+  formatPackageLine,
+};

package/src/workspace/filter-packages.js

@@ -1,5 +1,6 @@
 const readPackageJson = require("./read-package-json");
 const matchVersion = require("./match-version");
+const isStubTestScript = require("./is-stub-test-script");
 
 const DEFAULT_EXCLUDED_DIRS = ["cli"];
 
@@ -24,7 +25,12 @@ module.exports = (packages, options = {}) => {
   if (options.script) {
     result = result.filter((pkg) => {
       const pkgJson = readPackageJson(pkg.absDir);
-      return Boolean(pkgJson.scripts?.[options.script]);
+      const script = pkgJson.scripts?.[options.script];
+
+      if (!script) return false;
+      if (options.script === "test" && isStubTestScript(script)) return false;
+
+      return true;
     });
   }
 

package/src/workspace/is-stub-test-script.js

@@ -0,0 +1,5 @@
+const STUB_TEST_SCRIPT = 'echo "Error: no test specified" && exit 1';
+
+module.exports = (script) => script === STUB_TEST_SCRIPT;
+
+module.exports.STUB_TEST_SCRIPT = STUB_TEST_SCRIPT;