@vnejs/monorepo 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/monorepo",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Monorepo tooling for @vnejs",
   "main": "src/index.js",
   "bin": {

package/src/build/index.js

@@ -0,0 +1,64 @@
+const resolveGraph = require("../workspace/resolve-graph");
+const findRoot = require("../workspace/find-root");
+const { run } = require("../publish/utils");
+
+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=== Build: ${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})`);
+
+    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(`  ==> [${layerIndex + 1}/${layers.length}:${index + 1}/${layer.length}] ${pkg.name} (${pkg.dir})`);
+        });
+        continue;
+      }
+
+      runLayerTurbo(layer, root, { script, force: options.force });
+    }
+  }
+
+  if (dryRun) console.log("\nDry run complete.");
+};

package/src/bump/index.js

@@ -0,0 +1,106 @@
+const resolveGraph = require("../workspace/resolve-graph");
+const listWorkspacePackages = require("../workspace/list-packages");
+const syncDeps = require("../sync-deps");
+const runChanged = require("../run-changed");
+const { run } = require("../publish/utils");
+
+const PHASES = ["graph", "sync-all", "patch"];
+
+const parseMinorLine = (version) => {
+  const match = /^(\d+)\.(\d+)$/.exec(version);
+
+  if (!match) {
+    console.error("version must be major.minor, e.g. 0.1");
+    process.exit(1);
+  }
+
+  return { major: Number(match[1]), minor: Number(match[2]) };
+};
+
+const previousMinorLine = (version) => {
+  const { major, minor } = parseMinorLine(version);
+
+  if (minor > 0) return `${major}.${minor - 1}`;
+  if (major > 0) return `${major - 1}.9`;
+
+  console.error("cannot derive previous minor line from 0.0");
+  process.exit(1);
+};
+
+module.exports = (version, options = {}) => {
+  const dryRun = Boolean(options.dryRun);
+  const phases = options.phase ? [options.phase] : ["graph", "sync-all", "patch"];
+
+  if (options.phase && !PHASES.includes(options.phase)) {
+    console.error(`phase must be one of: ${PHASES.join(", ")}`);
+    process.exit(1);
+  }
+
+  parseMinorLine(version);
+
+  const expectVersion = options.expectVersion ?? version;
+  const onlyVersion = options.onlyVersion ?? previousMinorLine(version);
+
+  const graphOptions = {
+    cwd: options.cwd,
+    onlyVersion,
+    script: "publish:minor",
+  };
+
+  const syncOptions = {
+    expectVersion,
+    expectWaitMs: options.expectWaitMs,
+    expectMaxAttempts: options.expectMaxAttempts,
+    workspace: options.workspace,
+  };
+
+  if (phases.includes("graph")) {
+    const { order } = resolveGraph(graphOptions);
+
+    console.log(`\n=== Phase 1: sync-deps + publish:minor (${order.length} packages) ===`);
+    console.log(`Filter: ${onlyVersion}.x → target npm line: ${expectVersion}.x`);
+
+    if (!order.length) {
+      console.error("No packages matched graph filters for phase 1.");
+      process.exit(1);
+    }
+
+    order.forEach((pkg, index) => {
+      console.log(`\n==> [${index + 1}/${order.length}] ${pkg.name} (${pkg.dir})`);
+
+      if (dryRun) {
+        console.log(`  sync-deps --expect-version ${syncOptions.expectVersion}`);
+        console.log("  npm run publish:minor");
+        return;
+      }
+
+      syncDeps({ cwd: pkg.absDir, ...syncOptions });
+      run("npm run publish:minor", pkg.absDir);
+    });
+  }
+
+  if (phases.includes("sync-all")) {
+    const { packages } = listWorkspacePackages({ cwd: options.cwd });
+
+    console.log(`\n=== Phase 2: sync-deps --all (${packages.length} packages) ===`);
+
+    syncDeps({
+      cwd: options.cwd,
+      all: true,
+      dryRun,
+      quiet: false,
+      ...syncOptions,
+    });
+  }
+
+  if (phases.includes("patch")) {
+    console.log(`\n=== Phase 3: publish:changed:patch ===`);
+
+    runChanged("publish:patch", {
+      ref: options.ref ?? "HEAD",
+      dryRun,
+    });
+  }
+
+  if (dryRun) console.log("\nDry run complete.");
+};

package/src/changed-packages.js

@@ -1,27 +1,8 @@
 const { execSync } = require("child_process");
-const { existsSync, readFileSync } = require("fs");
+const { existsSync } = require("fs");
 const path = require("path");
-
-const readPackageJson = (pkgDir) => JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf8"));
-
-const findMonorepoRoot = (start = process.cwd()) => {
-  let dir = path.resolve(start);
-
-  while (true) {
-    const pkgPath = path.join(dir, "package.json");
-
-    if (existsSync(pkgPath)) {
-      const pkg = readPackageJson(dir);
-      if (pkg.workspaces) return dir;
-    }
-
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-
-  return path.resolve(start);
-};
+const readPackageJson = require("./workspace/read-package-json");
+const findMonorepoRoot = require("./workspace/find-root");
 
 const getChangedFiles = (root, ref = "HEAD") => {
   const files = new Set();

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,13 @@ const { Command } = require("commander");
 
 const packageJson = require("../package.json");
 const publishAction = require("./publish");
-const publishUisAction = require("./publish-uis");
-const publishHelpersAction = require("./publish-helpers");
-const publishConfigsAction = require("./publish-configs");
 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 clearAction = require("./clear");
 
 const program = new Command();
 
@@ -32,34 +34,62 @@ program
   .action(publishAction);
 
 program
-  .command("publish-uis")
-  .description("Publish all uis workspace packages in dependency order")
-  .argument("<bump>", "major | minor | patch")
-  .option("--access <access>", "npm publish --access", "public")
-  .option("--dry-run", "npm publish --dry-run", false)
-  .option("--otp <otp>", "npm publish --otp")
-  .option("--tag <tag>", "npm publish --tag", "latest")
-  .action(publishUisAction);
+  .command("graph")
+  .description("Show workspace packages in publish order (dependencies first)")
+  .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("--format <format>", "output format: text | json", "text")
+  .action(graphAction);
 
 program
-  .command("publish-helpers")
-  .description("Publish all helpers workspace packages in dependency order")
-  .argument("<bump>", "major | minor | patch")
-  .option("--access <access>", "npm publish --access", "public")
-  .option("--dry-run", "npm publish --dry-run", false)
-  .option("--otp <otp>", "npm publish --otp")
-  .option("--tag <tag>", "npm publish --tag", "latest")
-  .action(publishHelpersAction);
+  .command("sync-deps")
+  .description("Sync @vnejs/* dependency ranges in current package to latest npm minor versions (~x.y.0)")
+  .option("--dry-run", "show changes without writing package.json", false)
+  .option("--workspace", "use workspace package.json versions instead of npm registry", false)
+  .option("--all", "sync dependencies in all workspace packages", false)
+  .option("--expect-version <version>", "wait until npm has this major.minor line, e.g. 0.1")
+  .option("--expect-wait <ms>", "delay between npm retries", "10000")
+  .option("--expect-attempts <count>", "max npm retries per dependency", "12")
+  .action((options) =>
+    syncDepsAction({
+      ...options,
+      expectWaitMs: Number(options.expectWait),
+      expectMaxAttempts: Number(options.expectAttempts),
+    }),
+  );
 
 program
-  .command("publish-configs")
-  .description("Publish all configs workspace packages in dependency order")
-  .argument("<bump>", "major | minor | patch")
-  .option("--access <access>", "npm publish --access", "public")
-  .option("--dry-run", "npm publish --dry-run", false)
-  .option("--otp <otp>", "npm publish --otp")
-  .option("--tag <tag>", "npm publish --tag", "latest")
-  .action(publishConfigsAction);
+  .command("bump")
+  .description("Minor-line bump: graph publish, sync all deps, patch changed")
+  .argument("<version>", "target major.minor line, e.g. 0.1")
+  .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("--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")
+  .option("--expect-attempts <count>", "max npm retries per dependency", "12")
+  .action((version, options) =>
+    bumpAction(version, {
+      ...options,
+      expectWaitMs: Number(options.expectWait),
+      expectMaxAttempts: Number(options.expectAttempts),
+    }),
+  );
+
+program
+  .command("build")
+  .description("Build 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("--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")
@@ -69,7 +99,9 @@ program
   .action((options) => {
     const { packages } = getChangedPackages({ ref: options.ref, script: options.script });
 
-    packages.forEach((pkg) => console.log(`${pkg.name}\t${pkg.dir}`));
+    packages.forEach((pkg, index) => {
+      console.log(`==> [${index + 1}/${packages.length}] ${pkg.name} (${pkg.dir})`);
+    });
     console.log("");
     console.log(`Total: ${packages.length}`);
   });
@@ -82,4 +114,9 @@ program
   .option("--dry-run", "list packages without 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

@@ -0,0 +1,58 @@
+const path = require("path");
+const resolveGraph = require("../workspace/resolve-graph");
+
+module.exports = (options = {}) => {
+  const { root, order, layers } = resolveGraph(options);
+
+  if (!order.length) {
+    console.log("No workspace packages matched the provided filters.");
+    return { root, packages: [], layers: [], order: [] };
+  }
+
+  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 })),
+          ),
+          order: order.map((pkg) => ({ name: pkg.name, version: pkg.version, dir: pkg.dir })),
+        },
+        null,
+        2,
+      ),
+    );
+
+    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})`);
+
+      layer.forEach((pkg) => {
+        console.log(`${pkg.name}\t${pkg.version}\t${pkg.dir}`);
+      });
+
+      if (index < layers.length - 1) console.log("");
+    });
+  } else {
+    order.forEach((pkg, index) => {
+      console.log(`${index + 1}\t${pkg.name}\t${pkg.version}\t${pkg.dir}`);
+    });
+  }
+
+  console.log("");
+  console.log(`Root: ${path.relative(process.cwd(), root) || "."}`);
+  console.log(`Packages: ${order.length}`);
+  console.log(`Layers: ${layers.length}`);
+
+  return {
+    root,
+    packages: order,
+    layers,
+    order: order.map((pkg) => pkg.name),
+  };
+};

package/src/index.js

@@ -1,9 +1,16 @@
 module.exports = {
   package: require("./package"),
   publish: require("./publish"),
-  publishUis: require("./publish-uis"),
-  publishHelpers: require("./publish-helpers"),
-  publishConfigs: require("./publish-configs"),
   getChangedPackages: require("./changed-packages").getChangedPackages,
   runChanged: require("./run-changed"),
+  graph: require("./graph"),
+  syncDeps: require("./sync-deps"),
+  bump: require("./bump"),
+  build: require("./build"),
+  clear: require("./clear"),
+  resolveGraph: require("./workspace/resolve-graph"),
+  listWorkspacePackages: require("./workspace/list-packages"),
+  toTildeMinor: require("./workspace/to-tilde-minor"),
+  fetchNpmVersion: require("./workspace/fetch-npm-version"),
+  expectVersion: require("./workspace/expect-version"),
 };

package/src/run-changed/index.js

@@ -11,9 +11,9 @@ module.exports = (script, options = {}) => {
     return;
   }
 
-  for (const pkg of packages) {
+  for (const [index, pkg] of packages.entries()) {
     const pkgDir = path.join(root, pkg.dir);
-    console.log(`> ${pkg.name} (${pkg.dir})`);
+    console.log(`\n==> [${index + 1}/${packages.length}] ${pkg.name} (${pkg.dir})`);
 
     if (options.dryRun) continue;
 

package/src/sync-deps/index.js

@@ -0,0 +1,132 @@
+const { existsSync, writeFileSync } = require("fs");
+const path = require("path");
+const readPackageJson = require("../workspace/read-package-json");
+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 resolveVersion = (name, options) => {
+  if (options.workspace) {
+    return options.workspaceVersions.get(name) ?? null;
+  }
+
+  return fetchNpmVersion(name, {
+    expectVersion: options.expectVersion,
+    expectWaitMs: options.expectWaitMs,
+    expectMaxAttempts: options.expectMaxAttempts,
+  });
+};
+
+const syncPackageDeps = (options = {}) => {
+  const pkgDir = path.resolve(options.cwd ?? process.cwd());
+  const pkgPath = path.join(pkgDir, "package.json");
+
+  if (!existsSync(pkgPath)) {
+    if (options.exitOnMissing !== false) {
+      console.error("package.json not found in current directory");
+      process.exit(1);
+    }
+
+    return null;
+  }
+
+  const workspaceVersions = options.workspace
+    ? new Map(listWorkspacePackages({ cwd: pkgDir }).packages.map((pkg) => [pkg.name, pkg.version]))
+    : new Map();
+
+  const pkg = readPackageJson(pkgDir);
+  const changes = [];
+  const skipped = [];
+  const versionSource = options.workspace ? "workspace" : "npm";
+
+  for (const field of DEPENDENCY_FIELDS) {
+    const deps = pkg[field];
+    if (!deps) continue;
+
+    for (const [name, range] of Object.entries(deps)) {
+      if (!name.startsWith("@vnejs/")) continue;
+
+      const version = resolveVersion(name, {
+        workspace: options.workspace,
+        workspaceVersions,
+        expectVersion: options.expectVersion,
+        expectWaitMs: options.expectWaitMs,
+        expectMaxAttempts: options.expectMaxAttempts,
+      });
+      if (!version) {
+        skipped.push(name);
+        continue;
+      }
+
+      const next = toTildeMinor(version);
+      if (range === next) continue;
+
+      changes.push({ field, name, from: range, to: next, version });
+      deps[name] = next;
+    }
+  }
+
+  if (skipped.length) {
+    console.warn(`Skipped ${skipped.length} packages not found in ${versionSource}: ${skipped.join(", ")}`);
+  }
+
+  if (!changes.length) {
+    if (!options.quiet) {
+      console.log(`${pkg.name ?? path.basename(pkgDir)}: all @vnejs dependencies are up to date`);
+    }
+
+    return { packageName: pkg.name, dir: path.relative(options.root ?? pkgDir, pkgDir), changes, skipped };
+  }
+
+  for (const change of changes) {
+    console.log(`${change.field}: ${change.name} ${change.from} -> ${change.to} (${versionSource} ${change.version})`);
+  }
+
+  if (options.dryRun) {
+    console.log(`\nDry run: ${changes.length} dependencies would be updated`);
+    return { packageName: pkg.name, dir: path.relative(options.root ?? pkgDir, pkgDir), changes, skipped };
+  }
+
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  console.log(`\nUpdated ${changes.length} dependencies in ${pkg.name}`);
+
+  return { packageName: pkg.name, dir: path.relative(options.root ?? pkgDir, pkgDir), changes, skipped };
+};
+
+module.exports = (options = {}) => {
+  if (options.all) {
+    const { root, packages } = listWorkspacePackages({ cwd: options.cwd });
+    const results = [];
+
+    console.log(`Syncing dependencies in ${packages.length} workspace packages...`);
+
+    for (const pkg of packages) {
+      console.log(`\n==> ${pkg.name} (${pkg.dir})`);
+
+      if (options.dryRun) {
+        console.log("  sync-deps");
+        results.push({ packageName: pkg.name, dir: pkg.dir, dryRun: true });
+        continue;
+      }
+
+      const result = syncPackageDeps({
+        ...options,
+        cwd: pkg.absDir,
+        root,
+        exitOnMissing: false,
+        all: false,
+      });
+
+      if (result) results.push(result);
+    }
+
+    const updated = results.filter((result) => result.changes?.length);
+    console.log(`\nSynced ${packages.length} packages, updated ${updated.length}`);
+    return results;
+  }
+
+  return syncPackageDeps(options);
+};
+
+module.exports.syncPackageDeps = syncPackageDeps;

package/src/workspace/build-graph.js

@@ -0,0 +1,65 @@
+const readPackageJson = require("./read-package-json");
+
+const DEPENDENCY_FIELDS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+
+const buildDependencyGraph = (packages) => {
+  const byName = new Map(packages.map((pkg) => [pkg.name, pkg]));
+  const graph = new Map();
+
+  for (const pkg of packages) {
+    const deps = new Set();
+    const pkgJson = readPackageJson(pkg.absDir);
+
+    for (const field of DEPENDENCY_FIELDS) {
+      const fieldDeps = pkgJson[field];
+      if (!fieldDeps) continue;
+
+      for (const depName of Object.keys(fieldDeps)) {
+        if (byName.has(depName)) deps.add(depName);
+      }
+    }
+
+    graph.set(pkg.name, [...deps].sort());
+  }
+
+  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();
+
+  for (const name of packageNames) {
+    restricted.set(
+      name,
+      (graph.get(name) ?? []).filter((dep) => names.has(dep)),
+    );
+  }
+
+  return restricted;
+};
+
+module.exports = {
+  DEPENDENCY_FIELDS,
+  buildDependencyGraph,
+  expandDependencyClosure,
+  restrictGraph,
+};

package/src/workspace/expect-version.js

@@ -0,0 +1,39 @@
+module.exports.parseExpectVersion = (value) => {
+  if (!value) return null;
+
+  const normalized = String(value).trim().replace(/\.x$/, "");
+  const [major, minor] = normalized.split(".");
+
+  if (!major || minor === undefined) return null;
+
+  return `${major}.${minor}`;
+};
+
+module.exports.versionMatchesExpect = (version, expectVersion) => {
+  const parsed = module.exports.parseExpectVersion(expectVersion);
+  if (!parsed || !version) return false;
+
+  const [expectedMajor, expectedMinor] = parsed.split(".");
+  const [major, minor] = String(version).split(".");
+
+  return major === expectedMajor && minor === expectedMinor;
+};
+
+module.exports.shouldWaitForExpectVersion = (version, expectVersion) => {
+  const parsed = module.exports.parseExpectVersion(expectVersion);
+  if (!parsed) return false;
+  if (!version) return true;
+
+  const [expectedMajor, expectedMinor] = parsed.split(".").map(Number);
+  const [major, minor] = String(version).split(".").map(Number);
+
+  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(expectedMajor) || Number.isNaN(expectedMinor)) {
+    return true;
+  }
+
+  if (major > expectedMajor || (major === expectedMajor && minor > expectedMinor)) {
+    return false;
+  }
+
+  return !module.exports.versionMatchesExpect(version, parsed);
+};

package/src/workspace/fetch-npm-version.js

@@ -0,0 +1,57 @@
+const { execSync } = require("child_process");
+const { parseExpectVersion, shouldWaitForExpectVersion } = require("./expect-version");
+
+const fetchRaw = (name) => {
+  try {
+    return execSync(`npm view ${JSON.stringify(name)} version`, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return null;
+  }
+};
+
+const clearNpmCache = () => {
+  execSync("npm cache clean --force", { stdio: "inherit" });
+};
+
+const sleepSync = (ms) => {
+  execSync(`sleep ${Math.max(1, Math.ceil(ms / 1000))}`, { stdio: "ignore" });
+};
+
+module.exports = (name, options = {}) => {
+  const expectVersion = parseExpectVersion(options.expectVersion);
+
+  if (!expectVersion) {
+    return fetchRaw(name);
+  }
+
+  const waitMs = options.expectWaitMs ?? 10000;
+  const maxAttempts = options.expectMaxAttempts ?? 12;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const version = fetchRaw(name);
+
+    if (!shouldWaitForExpectVersion(version, expectVersion)) {
+      return version;
+    }
+
+    if (attempt === maxAttempts) {
+      console.warn(
+        `${name}: expected ${expectVersion}.x on npm, last seen: ${version ?? "not found"} — giving up`,
+      );
+      return version;
+    }
+
+    console.warn(
+      `${name}: expected ${expectVersion}.x on npm, got ${version ?? "not found"} — npm cache clean, wait ${waitMs / 1000}s (${attempt}/${maxAttempts})`,
+    );
+    clearNpmCache();
+    sleepSync(waitMs);
+  }
+
+  return null;
+};
+
+module.exports.fetchRaw = fetchRaw;

package/src/workspace/filter-packages.js

@@ -0,0 +1,35 @@
+const readPackageJson = require("./read-package-json");
+const matchVersion = require("./match-version");
+
+const DEFAULT_EXCLUDED_DIRS = ["cli"];
+
+const isExcludedDir = (dir, excludedDirs) =>
+  excludedDirs.some((excluded) => dir === excluded || dir.startsWith(`${excluded}/`));
+
+module.exports = (packages, options = {}) => {
+  let result = packages;
+  const excludedDirs = options.excludeDirs ?? DEFAULT_EXCLUDED_DIRS;
+
+  result = result.filter((pkg) => !isExcludedDir(pkg.dir, excludedDirs));
+
+  if (options.onlyVersion) {
+    result = result.filter((pkg) => matchVersion(pkg.version, options.onlyVersion));
+  }
+
+  if (options.name) {
+    const pattern = options.name.toLowerCase();
+    result = result.filter((pkg) => pkg.name.toLowerCase().includes(pattern));
+  }
+
+  if (options.script) {
+    result = result.filter((pkg) => {
+      const pkgJson = readPackageJson(pkg.absDir);
+      return Boolean(pkgJson.scripts?.[options.script]);
+    });
+  }
+
+  return result;
+};
+
+module.exports.DEFAULT_EXCLUDED_DIRS = DEFAULT_EXCLUDED_DIRS;
+module.exports.isExcludedDir = isExcludedDir;

package/src/workspace/find-root.js

@@ -0,0 +1,22 @@
+const { existsSync } = require("fs");
+const path = require("path");
+const readPackageJson = require("./read-package-json");
+
+module.exports = (start = process.cwd()) => {
+  let dir = path.resolve(start);
+
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+
+    if (existsSync(pkgPath)) {
+      const pkg = readPackageJson(dir);
+      if (pkg.workspaces) return dir;
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return path.resolve(start);
+};

package/src/workspace/list-packages.js

@@ -0,0 +1,82 @@
+const { existsSync, readdirSync } = require("fs");
+const path = require("path");
+const readPackageJson = require("./read-package-json");
+const findMonorepoRoot = require("./find-root");
+
+const expandWorkspacePattern = (root, pattern) => {
+  const results = [];
+  const parts = pattern.split("/");
+
+  const walk = (dir, idx) => {
+    if (idx >= parts.length) {
+      if (existsSync(path.join(dir, "package.json"))) results.push(dir);
+      return;
+    }
+
+    const part = parts[idx];
+
+    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") {
+          const subdir = path.join(dir, entry.name);
+          walk(subdir, idx + 1);
+          walk(subdir, idx);
+        }
+      }
+
+      return;
+    }
+
+    if (part === "*") {
+      if (!existsSync(dir)) return;
+
+      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);
+        }
+      }
+
+      return;
+    }
+
+    walk(path.join(dir, part), idx + 1);
+  };
+
+  walk(root, 0);
+  return results;
+};
+
+const listWorkspacePackages = (options = {}) => {
+  const root = options.root ?? findMonorepoRoot(options.cwd);
+  const rootPkg = readPackageJson(root);
+  const workspaces = rootPkg.workspaces ?? [];
+  const dirs = new Set();
+
+  for (const pattern of workspaces) {
+    for (const dir of expandWorkspacePattern(root, pattern)) {
+      dirs.add(dir);
+    }
+  }
+
+  const packages = [];
+
+  for (const absDir of [...dirs].sort()) {
+    const pkg = readPackageJson(absDir);
+    if (!pkg.name) continue;
+
+    packages.push({
+      name: pkg.name,
+      version: pkg.version ?? "0.0.0",
+      dir: path.relative(root, absDir) || ".",
+      absDir,
+    });
+  }
+
+  return { root, packages };
+};
+
+module.exports = listWorkspacePackages;

package/src/workspace/match-version.js

@@ -0,0 +1,7 @@
+module.exports = (version, filter) => {
+  if (!filter) return true;
+
+  const normalized = filter.endsWith(".x") ? filter.slice(0, -1) : filter;
+
+  return version.startsWith(normalized);
+};

package/src/workspace/read-package-json.js

@@ -0,0 +1,4 @@
+const { readFileSync } = require("fs");
+const path = require("path");
+
+module.exports = (pkgDir) => JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf8"));

package/src/workspace/resolve-graph.js

@@ -0,0 +1,29 @@
+const listWorkspacePackages = require("./list-packages");
+const filterPackages = require("./filter-packages");
+const { buildDependencyGraph, expandDependencyClosure, restrictGraph } = require("./build-graph");
+const { topoSort, topoSortLayers } = require("./topo-sort");
+
+module.exports = (options = {}) => {
+  const { root, packages } = listWorkspacePackages({ cwd: options.cwd });
+  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 { 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 };
+};

package/src/workspace/to-tilde-minor.js

@@ -0,0 +1,7 @@
+module.exports = (version) => {
+  const [major, minor = "0"] = String(version).split(".");
+
+  if (major === "0" && minor === "0") return "~0.0.1";
+
+  return `~${major}.${minor}.0`;
+};

package/src/workspace/topo-sort.js

@@ -0,0 +1,49 @@
+const topoSortLayers = (graph, packageNames) => {
+  const names = [...packageNames].sort();
+  const nameSet = new Set(names);
+  const inDegree = new Map(names.map((name) => [name, 0]));
+  const dependents = new Map(names.map((name) => [name, new Set()]));
+
+  for (const name of names) {
+    for (const dep of graph.get(name) ?? []) {
+      if (!nameSet.has(dep)) continue;
+
+      inDegree.set(name, inDegree.get(name) + 1);
+      dependents.get(dep).add(name);
+    }
+  }
+
+  const layers = [];
+  let queue = names.filter((name) => inDegree.get(name) === 0);
+
+  while (queue.length) {
+    layers.push(queue);
+
+    const next = [];
+
+    for (const name of queue) {
+      for (const dependent of dependents.get(name) ?? []) {
+        const degree = inDegree.get(dependent) - 1;
+        inDegree.set(dependent, degree);
+
+        if (degree === 0) next.push(dependent);
+      }
+    }
+
+    queue = next.sort();
+  }
+
+  if (layers.flat().length !== names.length) {
+    const remaining = names.filter((name) => !layers.flat().includes(name));
+    throw new Error(`Circular dependency detected: ${remaining.join(", ")}`);
+  }
+
+  return layers;
+};
+
+const topoSort = (graph, packageNames) => topoSortLayers(graph, packageNames).flat();
+
+module.exports = {
+  topoSort,
+  topoSortLayers,
+};

package/src/publish-configs/index.js

@@ -1,38 +0,0 @@
-const { execSync } = require("child_process");
-const { existsSync } = require("fs");
-const path = require("path");
-
-module.exports = (bump, options = {}) => {
-  if (!["major", "minor", "patch"].includes(bump)) {
-    console.error("bump must be major, minor, or patch");
-    process.exit(1);
-  }
-
-  const root = process.cwd();
-  const configsRoot = path.join(root, "configs");
-
-  if (!existsSync(configsRoot)) {
-    console.error(`configs directory not found: ${configsRoot}`);
-    process.exit(1);
-  }
-
-  const packageDirs = [
-    path.join(configsRoot, "ts-common"),
-    path.join(configsRoot, "ts-uis"),
-  ].filter((pkgDir) => existsSync(pkgDir));
-
-  const access = options.access || "public";
-  const publishArgs = [`npx @vnejs/monorepo publish ${bump}`, `--access ${access}`];
-  if (options.dryRun) publishArgs.push("--dry-run");
-  if (options.otp) publishArgs.push(`--otp ${options.otp}`);
-  if (options.tag && options.tag !== "latest") publishArgs.push(`--tag ${options.tag}`);
-
-  const command = publishArgs.join(" ");
-
-  for (const pkgDir of packageDirs) {
-    console.log(`\n==> ${path.relative(root, pkgDir)}`);
-    execSync(command, { cwd: pkgDir, stdio: "inherit" });
-  }
-
-  console.log(`\nPublished ${packageDirs.length} configs packages (${bump}).`);
-};

package/src/publish-helpers/index.js

@@ -1,36 +0,0 @@
-const { execSync } = require("child_process");
-const { existsSync } = require("fs");
-const path = require("path");
-const getHelpersLayers = require("../layers/helpers");
-
-module.exports = (bump, options = {}) => {
-  if (!["major", "minor", "patch"].includes(bump)) {
-    console.error("bump must be major, minor, or patch");
-    process.exit(1);
-  }
-
-  const root = process.cwd();
-  const helpersRoot = path.join(root, "helpers");
-
-  if (!existsSync(helpersRoot)) {
-    console.error(`helpers directory not found: ${helpersRoot}`);
-    process.exit(1);
-  }
-
-  const packageDirs = getHelpersLayers(root).flatMap((layer) => layer.packageDirs);
-
-  const access = options.access || "public";
-  const publishArgs = [`npx @vnejs/monorepo publish ${bump}`, `--access ${access}`];
-  if (options.dryRun) publishArgs.push("--dry-run");
-  if (options.otp) publishArgs.push(`--otp ${options.otp}`);
-  if (options.tag && options.tag !== "latest") publishArgs.push(`--tag ${options.tag}`);
-
-  const command = publishArgs.join(" ");
-
-  for (const pkgDir of packageDirs) {
-    console.log(`\n==> ${path.relative(root, pkgDir)}`);
-    execSync(command, { cwd: pkgDir, stdio: "inherit" });
-  }
-
-  console.log(`\nPublished ${packageDirs.length} helpers packages (${bump}).`);
-};

package/src/publish-uis/index.js

@@ -1,36 +0,0 @@
-const { execSync } = require("child_process");
-const { existsSync } = require("fs");
-const path = require("path");
-const getUisLayers = require("../layers/uis");
-
-module.exports = (bump, options = {}) => {
-  if (!["major", "minor", "patch"].includes(bump)) {
-    console.error("bump must be major, minor, or patch");
-    process.exit(1);
-  }
-
-  const root = process.cwd();
-  const uisRoot = path.join(root, "uis");
-
-  if (!existsSync(uisRoot)) {
-    console.error(`uis directory not found: ${uisRoot}`);
-    process.exit(1);
-  }
-
-  const packageDirs = getUisLayers(root).flatMap((layer) => layer.packageDirs);
-
-  const access = options.access || "public";
-  const publishArgs = [`npx @vnejs/monorepo publish ${bump}`, `--access ${access}`];
-  if (options.dryRun) publishArgs.push("--dry-run");
-  if (options.otp) publishArgs.push(`--otp ${options.otp}`);
-  if (options.tag && options.tag !== "latest") publishArgs.push(`--tag ${options.tag}`);
-
-  const command = publishArgs.join(" ");
-
-  for (const pkgDir of packageDirs) {
-    console.log(`\n==> ${path.relative(root, pkgDir)}`);
-    execSync(command, { cwd: pkgDir, stdio: "inherit" });
-  }
-
-  console.log(`\nPublished ${packageDirs.length} uis packages (${bump}).`);
-};