@vnejs/monorepo 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/monorepo",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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/clear/index.js

@@ -0,0 +1,24 @@
+const findRoot = require("../workspace/find-root");
+const { run } = require("../publish/utils");
+
+module.exports = (options = {}) => {
+  const root = findRoot(options.cwd ?? process.cwd());
+
+  console.log(`Monorepo root: ${root}\n`);
+
+  console.log("==> Removing node_modules...");
+  run("rm -rf node_modules", root);
+  run('find . -name node_modules -type d -prune -exec rm -rf {} +', root);
+
+  console.log("==> Removing Turbo cache...");
+  run("rm -rf .turbo", root);
+  run('find . -name .turbo -type d -prune -exec rm -rf {} +', root);
+
+  console.log("==> Removing dist folders...");
+  run('find . -name dist -type d -prune -exec rm -rf {} +', root);
+
+  console.log("==> Removing package-lock files...");
+  run('find . -name package-lock.json -type f -delete', root);
+
+  console.log("\n==> Clear complete.");
+};

package/src/cli.js

@@ -4,11 +4,12 @@ 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 runAction = require("./run");
+const clearAction = require("./clear");
 
 const program = new Command();
 
@@ -37,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);
 
@@ -65,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")
@@ -79,26 +80,33 @@ program
   );
 
 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 });
+  .command("test")
+  .description("run vitest in current directory")
+  .action((options) => require("./test")(options));
 
-    packages.forEach((pkg, index) => {
-      console.log(`==> [${index + 1}/${packages.length}] ${pkg.name} (${pkg.dir})`);
-    });
-    console.log("");
-    console.log(`Total: ${packages.length}`);
-  });
+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", "run one package at a time in flat graph order", false)
+  .option("--force", "pass --force to turbo (bypass cache)", false)
+  .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
+  .command("clear")
+  .description("Clean node_modules, caches, dist, and lockfiles")
+  .action(clearAction);
+
 program.parse();

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,11 +1,14 @@
 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"),
+  run: require("./run"),
+  clear: require("./clear"),
   resolveGraph: require("./workspace/resolve-graph"),
   listWorkspacePackages: require("./workspace/list-packages"),
   toTildeMinor: require("./workspace/to-tilde-minor"),

package/src/run/index.js

@@ -0,0 +1,70 @@
+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(" ");
+  const forceFlag = force ? " --force" : "";
+
+  run(`npx turbo run ${script} ${filters}${forceFlag}`, root);
+};
+
+module.exports = (options = {}) => {
+  const script = options.script ?? "build";
+  const root = findRoot(options.cwd ?? process.cwd());
+  const dryRun = Boolean(options.dryRun);
+  const sequential = Boolean(options.sequential);
+
+  const { order, layers } = resolveGraph({
+    cwd: options.cwd ?? root,
+    script,
+    onlyVersion: options.onlyVersion,
+    name: options.name,
+    includeDependencies: Boolean(options.name || options.onlyVersion),
+  });
+
+  if (!order.length) {
+    console.error(`No workspace packages matched filters with script "${script}".`);
+    process.exit(1);
+  }
+
+  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(formatPackageLine(pkg, { leadingNewline: true, tag: label }));
+
+    if (dryRun) return;
+
+    run(`npm run ${script}`, pkg.absDir);
+  };
+
+  if (sequential) {
+    order.forEach((pkg, index) => runPackage(pkg, `[${index + 1}/${order.length}]`));
+  } else {
+    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
+      const layer = layers[layerIndex];
+      console.log(`\n=== Layer ${layerIndex + 1}/${layers.length} (${layer.length} packages) ===`);
+
+      if (dryRun) {
+        console.log(`  turbo run ${script} ${layer.map((pkg) => `--filter=${pkg.name}`).join(" ")}`);
+        layer.forEach((pkg, index) => {
+          console.log(
+            formatPackageLine(pkg, {
+              indent: "  ",
+              tag: `[${layerIndex + 1}/${layers.length}:${index + 1}/${layer.length}]`,
+            }),
+          );
+        });
+        continue;
+      }
+
+      runLayerTurbo(layer, root, { script, force: options.force });
+    }
+  }
+
+  if (dryRun) console.log("\nDry run complete.");
+};

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/build-graph.js

@@ -25,6 +25,24 @@ const buildDependencyGraph = (packages) => {
   return { graph, byName };
 };
 
+const expandDependencyClosure = (packageNames, graph, byName) => {
+  const expanded = new Set(packageNames);
+  const queue = [...packageNames];
+
+  while (queue.length) {
+    const name = queue.shift();
+
+    for (const dep of graph.get(name) ?? []) {
+      if (!byName.has(dep) || expanded.has(dep)) continue;
+
+      expanded.add(dep);
+      queue.push(dep);
+    }
+  }
+
+  return [...expanded];
+};
+
 const restrictGraph = (graph, packageNames) => {
   const names = new Set(packageNames);
   const restricted = new Map();
@@ -42,5 +60,6 @@ const restrictGraph = (graph, packageNames) => {
 module.exports = {
   DEPENDENCY_FIELDS,
   buildDependencyGraph,
+  expandDependencyClosure,
   restrictGraph,
 };

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;

package/src/workspace/list-packages.js

@@ -18,9 +18,13 @@ const expandWorkspacePattern = (root, pattern) => {
     if (part === "**") {
       if (!existsSync(dir)) return;
 
+      walk(dir, idx + 1);
+
       for (const entry of readdirSync(dir, { withFileTypes: true })) {
         if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
-          walk(path.join(dir, entry.name), idx + 1);
+          const subdir = path.join(dir, entry.name);
+          walk(subdir, idx + 1);
+          walk(subdir, idx);
         }
       }
 

package/src/workspace/resolve-graph.js

@@ -1,26 +1,28 @@
 const listWorkspacePackages = require("./list-packages");
 const filterPackages = require("./filter-packages");
-const { buildDependencyGraph, restrictGraph } = require("./build-graph");
+const { buildDependencyGraph, expandDependencyClosure, restrictGraph } = require("./build-graph");
 const { topoSort, topoSortLayers } = require("./topo-sort");
 
 module.exports = (options = {}) => {
   const { root, packages } = listWorkspacePackages({ cwd: options.cwd });
-  const selected = filterPackages(packages, options);
+  let selected = filterPackages(packages, options);
 
   if (!selected.length) {
     return { root, selected: [], order: [], layers: [], byName: new Map() };
   }
 
   const byName = new Map(packages.map((pkg) => [pkg.name, pkg]));
-  const restricted = restrictGraph(
-    buildDependencyGraph(packages).graph,
-    selected.map((pkg) => pkg.name),
-  );
-  const layerNames = topoSortLayers(
-    restricted,
-    selected.map((pkg) => pkg.name),
-  );
-  const order = topoSort(restricted, selected.map((pkg) => pkg.name)).map((name) => byName.get(name));
+  const { graph } = buildDependencyGraph(packages);
+  let packageNames = selected.map((pkg) => pkg.name);
+
+  if (options.includeDependencies && packageNames.length) {
+    packageNames = expandDependencyClosure(packageNames, graph, byName);
+    selected = packageNames.map((name) => byName.get(name)).filter(Boolean);
+  }
+
+  const restricted = restrictGraph(graph, packageNames);
+  const layerNames = topoSortLayers(restricted, packageNames);
+  const order = topoSort(restricted, packageNames).map((name) => byName.get(name));
   const layers = layerNames.map((layer) => layer.map((name) => byName.get(name)));
 
   return { root, selected, order, layers, byName };