@turbo/workspaces 0.0.1

package/dist/cli.js

@@ -0,0 +1,1038 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+
+// src/cli.ts
+var import_chalk6 = __toESM(require("chalk"));
+var import_commander = require("commander");
+
+// src/commands/summary/index.ts
+var import_inquirer = __toESM(require("inquirer"));
+var import_path6 = __toESM(require("path"));
+
+// src/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var import_gradient_string = __toESM(require("gradient-string"));
+var INDENTATION = 2;
+var Logger = class {
+  constructor({
+    interactive,
+    dry
+  } = {}) {
+    this.interactive = interactive != null ? interactive : true;
+    this.dry = dry != null ? dry : false;
+    this.step = 1;
+  }
+  logger(...args) {
+    if (this.interactive) {
+      console.log(...args);
+    }
+  }
+  indented(level, ...args) {
+    this.logger(" ".repeat(INDENTATION * level), ...args);
+  }
+  header(title) {
+    this.blankLine();
+    this.logger(import_chalk.default.bold(title));
+  }
+  installerFrames() {
+    const prefix = `${" ".repeat(INDENTATION)} - ${this.dry ? import_chalk.default.yellow("SKIPPED | ") : import_chalk.default.green("OK | ")}`;
+    return [`${prefix}   `, `${prefix}>  `, `${prefix}>> `, `${prefix}>>>`];
+  }
+  gradient(text) {
+    const turboGradient = (0, import_gradient_string.default)("#0099F7", "#F11712");
+    return turboGradient(text.toString());
+  }
+  hero() {
+    this.logger(import_chalk.default.bold(this.gradient(`
+>>> TURBOREPO
+`)));
+  }
+  info(...args) {
+    this.logger(...args);
+  }
+  mainStep(title) {
+    this.blankLine();
+    this.logger(`${this.step}. ${import_chalk.default.underline(title)}`);
+    this.step += 1;
+  }
+  subStep(...args) {
+    this.logger(" ".repeat(INDENTATION), `-`, this.dry ? import_chalk.default.yellow("SKIPPED |") : import_chalk.default.green("OK |"), ...args);
+  }
+  subStepFailure(...args) {
+    this.logger(" ".repeat(INDENTATION), `-`, import_chalk.default.red("ERROR |"), ...args);
+  }
+  rootHeader() {
+    this.blankLine();
+    this.indented(2, "Root:");
+  }
+  rootStep(...args) {
+    this.logger(" ".repeat(INDENTATION * 3), `-`, this.dry ? import_chalk.default.yellow("SKIPPED |") : import_chalk.default.green("OK |"), ...args);
+  }
+  workspaceHeader() {
+    this.blankLine();
+    this.indented(2, "Workspaces:");
+  }
+  workspaceStep(...args) {
+    this.logger(" ".repeat(INDENTATION * 3), `-`, this.dry ? import_chalk.default.yellow("SKIPPED |") : import_chalk.default.green("OK |"), ...args);
+  }
+  blankLine() {
+    this.logger();
+  }
+  error(...args) {
+    console.error(...args);
+  }
+};
+
+// src/commands/summary/index.ts
+var import_chalk3 = __toESM(require("chalk"));
+
+// src/utils.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_js_yaml = __toESM(require("js-yaml"));
+
+// src/errors.ts
+var ConvertError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConvertError";
+    Error.captureStackTrace(this, ConvertError);
+  }
+};
+
+// src/utils.ts
+var PACKAGE_MANAGER_REGEX = /^(?!_)(.+)@(.+)$/;
+function getPackageJson({
+  workspaceRoot
+}) {
+  const packageJsonPath = import_path.default.join(workspaceRoot, "package.json");
+  try {
+    return import_fs_extra.default.readJsonSync(packageJsonPath, "utf8");
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err) {
+      if (err.code === "ENOENT") {
+        throw new ConvertError(`no "package.json" found at ${workspaceRoot}`);
+      }
+      if (err.code === "EJSONPARSE") {
+        throw new ConvertError(`failed to parse "package.json" at ${workspaceRoot}`);
+      }
+    }
+    throw new Error(`unexpected error reading "package.json" at ${workspaceRoot}`);
+  }
+}
+function getWorkspacePackageManager({
+  workspaceRoot
+}) {
+  const { packageManager } = getPackageJson({ workspaceRoot });
+  if (packageManager) {
+    try {
+      const match = packageManager.match(PACKAGE_MANAGER_REGEX);
+      if (match) {
+        const [_, manager] = match;
+        return manager;
+      }
+    } catch (err) {
+    }
+  }
+  return void 0;
+}
+function getWorkspaceName({
+  workspaceRoot
+}) {
+  const packageJson = getPackageJson({ workspaceRoot });
+  if (packageJson.name) {
+    return packageJson.name;
+  }
+  const workspaceDirectory = import_path.default.basename(workspaceRoot);
+  return workspaceDirectory;
+}
+function getPnpmWorkspaces({
+  workspaceRoot
+}) {
+  const workspaceFile = import_path.default.join(workspaceRoot, "pnpm-workspace.yaml");
+  if (import_fs_extra.default.existsSync(workspaceFile)) {
+    try {
+      const workspaceConfig = import_js_yaml.default.load(import_fs_extra.default.readFileSync(workspaceFile, "utf8"));
+      if (workspaceConfig instanceof Object && "packages" in workspaceConfig && Array.isArray(workspaceConfig.packages)) {
+        return workspaceConfig.packages;
+      }
+    } catch (err) {
+      throw new ConvertError(`failed to parse ${workspaceFile}`);
+    }
+  }
+  return [];
+}
+function expandPaths({
+  root,
+  lockFile,
+  workspaceConfig
+}) {
+  const fromRoot = (p) => import_path.default.join(root, p);
+  const paths = {
+    root,
+    lockfile: fromRoot(lockFile),
+    packageJson: fromRoot("package.json"),
+    nodeModules: fromRoot("node_modules")
+  };
+  if (workspaceConfig) {
+    paths.workspaceConfig = fromRoot(workspaceConfig);
+  }
+  return paths;
+}
+function expandWorkspaces({
+  workspaceRoot,
+  workspaceGlobs
+}) {
+  if (!workspaceGlobs) {
+    return [];
+  }
+  return workspaceGlobs.flatMap((workspaceGlob) => {
+    const workspacePackageJsonGlob = `${workspaceGlob}/package.json`;
+    return import_fast_glob.default.sync(workspacePackageJsonGlob, {
+      onlyFiles: true,
+      absolute: true,
+      cwd: workspaceRoot
+    });
+  }).map((workspacePackageJson) => {
+    const workspaceRoot2 = import_path.default.dirname(workspacePackageJson);
+    const name = getWorkspaceName({ workspaceRoot: workspaceRoot2 });
+    return {
+      name,
+      paths: {
+        root: workspaceRoot2,
+        packageJson: workspacePackageJson,
+        nodeModules: import_path.default.join(workspaceRoot2, "node_modules")
+      }
+    };
+  });
+}
+function directoryInfo({ directory }) {
+  const dir = import_path.default.resolve(process.cwd(), directory);
+  return { exists: import_fs_extra.default.existsSync(dir), absolute: dir };
+}
+
+// src/managers/pnpm.ts
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
+var import_execa = __toESM(require("execa"));
+
+// src/updateDependencies.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_path2 = __toESM(require("path"));
+function updateDependencyList({
+  dependencyList,
+  project,
+  to
+}) {
+  const updated = [];
+  project.workspaceData.workspaces.forEach((workspace) => {
+    const { name } = workspace;
+    if (dependencyList[name]) {
+      const workspaceVersion = dependencyList[name];
+      const version = workspaceVersion.startsWith("workspace:") ? workspaceVersion.slice("workspace:".length) : workspaceVersion;
+      dependencyList[name] = to.name === "pnpm" ? `workspace:${version}` : version;
+      updated.push(name);
+    }
+  });
+  return { dependencyList, updated };
+}
+function updateDependencies({
+  project,
+  workspace,
+  to,
+  logger,
+  options
+}) {
+  if (["yarn", "npm"].includes(to.name) && ["yarn", "npm"].includes(project.packageManager)) {
+    return;
+  }
+  const workspacePackageJson = getPackageJson({
+    workspaceRoot: workspace.paths.root
+  });
+  const stats = {
+    dependencies: [],
+    devDependencies: [],
+    peerDependencies: [],
+    optionalDependencies: []
+  };
+  const allDependencyKeys = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ];
+  allDependencyKeys.forEach((depKey) => {
+    const depList = workspacePackageJson[depKey];
+    if (depList) {
+      const { updated, dependencyList } = updateDependencyList({
+        dependencyList: depList,
+        project,
+        to
+      });
+      workspacePackageJson[depKey] = dependencyList;
+      stats[depKey] = updated;
+    }
+  });
+  const toLog = (key) => {
+    const total = stats[key].length;
+    if (total > 0) {
+      return `${import_chalk2.default.green(total.toString())} ${key}`;
+    }
+    return void 0;
+  };
+  const allChanges = allDependencyKeys.map(toLog).filter(Boolean);
+  const workspaceLocation = `./${import_path2.default.relative(project.paths.root, workspace.paths.packageJson)}`;
+  if (allChanges.length >= 1) {
+    let logLine = "updating";
+    allChanges.forEach((stat, idx) => {
+      if (allChanges.length === 1) {
+        logLine += ` ${stat} in ${workspaceLocation}`;
+      } else {
+        if (idx === allChanges.length - 1) {
+          logLine += `and ${stat} in ${workspaceLocation}`;
+        } else {
+          logLine += ` ${stat}, `;
+        }
+      }
+    });
+    logger.workspaceStep(logLine);
+  } else {
+    logger.workspaceStep(`no workspace dependencies found in ${workspaceLocation}`);
+  }
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra2.default.writeJSONSync(workspace.paths.packageJson, workspacePackageJson, {
+      spaces: 2
+    });
+  }
+}
+
+// src/managers/pnpm.ts
+async function detect(args) {
+  const lockFile = import_path3.default.join(args.workspaceRoot, "pnpm-lock.yaml");
+  const workspaceFile = import_path3.default.join(args.workspaceRoot, "pnpm-workspace.yaml");
+  const packageManager = getWorkspacePackageManager({
+    workspaceRoot: args.workspaceRoot
+  });
+  return import_fs_extra3.default.existsSync(lockFile) || import_fs_extra3.default.existsSync(workspaceFile) || packageManager === "pnpm";
+}
+async function read(args) {
+  const isPnpm = await detect(args);
+  if (!isPnpm) {
+    throw new ConvertError("Not a pnpm project");
+  }
+  return {
+    name: getWorkspaceName(args),
+    packageManager: "pnpm",
+    paths: expandPaths({
+      root: args.workspaceRoot,
+      lockFile: "pnpm-lock.yaml",
+      workspaceConfig: "pnpm-workspace.yaml"
+    }),
+    workspaceData: {
+      globs: getPnpmWorkspaces(args),
+      workspaces: expandWorkspaces({
+        workspaceGlobs: getPnpmWorkspaces(args),
+        ...args
+      })
+    }
+  };
+}
+async function create(args) {
+  const { project, to, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Creating ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  logger.rootHeader();
+  packageJson.packageManager = `${to.name}@${to.version}`;
+  logger.rootStep(`adding "packageManager" field to ${project.name} root "package.json"`);
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra3.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+    if (hasWorkspaces) {
+      logger.rootStep(`adding "pnpm-workspace.yaml"`);
+      import_fs_extra3.default.writeFileSync(import_path3.default.join(project.paths.root, "pnpm-workspace.yaml"), `packages:
+${project.workspaceData.globs.map((w) => `  - "${w}"`).join("\n")}`);
+    }
+  }
+  if (hasWorkspaces) {
+    updateDependencies({
+      workspace: { name: "root", paths: project.paths },
+      project,
+      to,
+      logger,
+      options
+    });
+    logger.workspaceHeader();
+    project.workspaceData.workspaces.forEach((workspace) => updateDependencies({ workspace, project, to, logger, options }));
+  }
+}
+async function remove(args) {
+  const { project, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Removing ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  if (project.paths.workspaceConfig && hasWorkspaces) {
+    logger.subStep(`removing "pnpm-workspace.yaml"`);
+    if (!(options == null ? void 0 : options.dry)) {
+      import_fs_extra3.default.rmSync(project.paths.workspaceConfig, { force: true });
+    }
+  }
+  logger.subStep(`removing "packageManager" field in ${project.name} root "package.json"`);
+  delete packageJson.packageManager;
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra3.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+    const allModulesDirs = [
+      project.paths.nodeModules,
+      ...project.workspaceData.workspaces.map((w) => w.paths.nodeModules)
+    ];
+    try {
+      logger.subStep(`removing "node_modules"`);
+      await Promise.all(allModulesDirs.map((dir) => import_fs_extra3.default.rm(dir, { recursive: true, force: true })));
+    } catch (err) {
+      throw new ConvertError("Failed to remove node_modules");
+    }
+  }
+}
+async function clean(args) {
+  const { project, logger, options } = args;
+  logger.subStep(`removing ${import_path3.default.relative(project.paths.root, project.paths.lockfile)}`);
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra3.default.rmSync(project.paths.lockfile, { force: true });
+  }
+}
+async function convertLock(args) {
+  const { project, logger, options } = args;
+  if (project.packageManager !== "pnpm") {
+    logger.subStep(`converting ${import_path3.default.relative(project.paths.root, project.paths.lockfile)} to pnpm-lock.yaml`);
+    if (!(options == null ? void 0 : options.dry) && import_fs_extra3.default.existsSync(project.paths.lockfile)) {
+      try {
+        await (0, import_execa.default)("pnpm", ["import"], {
+          stdio: "ignore",
+          cwd: project.paths.root
+        });
+      } finally {
+        import_fs_extra3.default.rmSync(project.paths.lockfile, { force: true });
+      }
+    }
+  }
+}
+var pnpm = {
+  detect,
+  read,
+  create,
+  remove,
+  clean,
+  convertLock
+};
+var pnpm_default = pnpm;
+
+// src/managers/npm.ts
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_path4 = __toESM(require("path"));
+async function detect2(args) {
+  const lockFile = import_path4.default.join(args.workspaceRoot, "package-lock.json");
+  const packageManager = getWorkspacePackageManager({
+    workspaceRoot: args.workspaceRoot
+  });
+  return import_fs_extra4.default.existsSync(lockFile) || packageManager === "npm";
+}
+async function read2(args) {
+  const isNpm = await detect2(args);
+  if (!isNpm) {
+    throw new ConvertError("Not an npm project");
+  }
+  const packageJson = getPackageJson(args);
+  return {
+    name: getWorkspaceName(args),
+    packageManager: "npm",
+    paths: expandPaths({
+      root: args.workspaceRoot,
+      lockFile: "package-lock.json"
+    }),
+    workspaceData: {
+      globs: packageJson.workspaces || [],
+      workspaces: expandWorkspaces({
+        workspaceGlobs: packageJson.workspaces,
+        ...args
+      })
+    }
+  };
+}
+async function create2(args) {
+  const { project, options, to, logger } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Creating ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  logger.rootHeader();
+  logger.rootStep(`adding "packageManager" field to ${project.name} root "package.json"`);
+  packageJson.packageManager = `${to.name}@${to.version}`;
+  if (hasWorkspaces) {
+    logger.rootStep(`adding "workspaces" field to ${project.name} root "package.json"`);
+    packageJson.workspaces = project.workspaceData.globs;
+    updateDependencies({
+      workspace: { name: "root", paths: project.paths },
+      project,
+      to,
+      logger,
+      options
+    });
+    logger.workspaceHeader();
+    project.workspaceData.workspaces.forEach((workspace) => updateDependencies({ workspace, project, to, logger, options }));
+  }
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra4.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+  }
+}
+async function remove2(args) {
+  const { project, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Creating ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  if (hasWorkspaces) {
+    logger.subStep(`removing "workspaces" field in ${project.name} root "package.json"`);
+    delete packageJson.workspaces;
+  }
+  logger.subStep(`removing "packageManager" field in ${project.name} root "package.json"`);
+  delete packageJson.packageManager;
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra4.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+    const allModulesDirs = [
+      project.paths.nodeModules,
+      ...project.workspaceData.workspaces.map((w) => w.paths.nodeModules)
+    ];
+    try {
+      logger.subStep(`removing "node_modules"`);
+      await Promise.all(allModulesDirs.map((dir) => import_fs_extra4.default.rm(dir, { recursive: true, force: true })));
+    } catch (err) {
+      throw new ConvertError("Failed to remove node_modules");
+    }
+  }
+}
+async function clean2(args) {
+  const { project, logger, options } = args;
+  logger.subStep(`removing ${import_path4.default.relative(project.paths.root, project.paths.lockfile)}`);
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra4.default.rmSync(project.paths.lockfile, { force: true });
+  }
+}
+async function convertLock2(args) {
+  const { project, options } = args;
+  if (project.packageManager !== "npm") {
+    if (!(options == null ? void 0 : options.dry)) {
+      import_fs_extra4.default.rmSync(project.paths.lockfile, { force: true });
+    }
+  }
+}
+var npm = {
+  detect: detect2,
+  read: read2,
+  create: create2,
+  remove: remove2,
+  clean: clean2,
+  convertLock: convertLock2
+};
+var npm_default = npm;
+
+// src/managers/yarn.ts
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_path5 = __toESM(require("path"));
+async function detect3(args) {
+  const lockFile = import_path5.default.join(args.workspaceRoot, "yarn.lock");
+  const packageManager = getWorkspacePackageManager({
+    workspaceRoot: args.workspaceRoot
+  });
+  return import_fs_extra5.default.existsSync(lockFile) || packageManager === "yarn";
+}
+async function read3(args) {
+  const isYarn = await detect3(args);
+  if (!isYarn) {
+    throw new ConvertError("Not a yarn project");
+  }
+  const packageJson = getPackageJson(args);
+  return {
+    name: getWorkspaceName(args),
+    packageManager: "yarn",
+    paths: expandPaths({
+      root: args.workspaceRoot,
+      lockFile: "yarn.lock"
+    }),
+    workspaceData: {
+      globs: packageJson.workspaces || [],
+      workspaces: expandWorkspaces({
+        workspaceGlobs: packageJson.workspaces,
+        ...args
+      })
+    }
+  };
+}
+async function create3(args) {
+  const { project, to, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Creating ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  logger.rootHeader();
+  logger.rootStep(`adding "packageManager" field to ${import_path5.default.relative(project.paths.root, project.paths.packageJson)}`);
+  packageJson.packageManager = `${to.name}@${to.version}`;
+  if (hasWorkspaces) {
+    logger.rootStep(`adding "workspaces" field to ${import_path5.default.relative(project.paths.root, project.paths.packageJson)}`);
+    packageJson.workspaces = project.workspaceData.globs;
+    updateDependencies({
+      workspace: { name: "root", paths: project.paths },
+      project,
+      to,
+      logger,
+      options
+    });
+    logger.workspaceHeader();
+    project.workspaceData.workspaces.forEach((workspace) => updateDependencies({ workspace, project, to, logger, options }));
+  }
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra5.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+  }
+}
+async function remove3(args) {
+  const { project, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Removing ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  if (hasWorkspaces) {
+    logger.subStep(`removing "workspaces" field in ${project.name} root "package.json"`);
+    delete packageJson.workspaces;
+  }
+  logger.subStep(`removing "packageManager" field in ${project.name} root "package.json"`);
+  delete packageJson.packageManager;
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra5.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+    const allModulesDirs = [
+      project.paths.nodeModules,
+      ...project.workspaceData.workspaces.map((w) => w.paths.nodeModules)
+    ];
+    try {
+      logger.subStep(`removing "node_modules"`);
+      await Promise.all(allModulesDirs.map((dir) => import_fs_extra5.default.rm(dir, { recursive: true, force: true })));
+    } catch (err) {
+      throw new ConvertError("Failed to remove node_modules");
+    }
+  }
+}
+async function clean3(args) {
+  const { project, logger, options } = args;
+  logger.subStep(`removing ${import_path5.default.relative(project.paths.root, project.paths.lockfile)}`);
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra5.default.rmSync(project.paths.lockfile, { force: true });
+  }
+}
+async function convertLock3(args) {
+  const { project, options } = args;
+  if (project.packageManager !== "yarn") {
+    if (!(options == null ? void 0 : options.dry)) {
+      import_fs_extra5.default.rmSync(project.paths.lockfile, { force: true });
+    }
+  }
+}
+var yarn = {
+  detect: detect3,
+  read: read3,
+  create: create3,
+  remove: remove3,
+  clean: clean3,
+  convertLock: convertLock3
+};
+var yarn_default = yarn;
+
+// src/managers/index.ts
+var MANAGERS = {
+  pnpm: pnpm_default,
+  yarn: yarn_default,
+  npm: npm_default
+};
+var managers_default = MANAGERS;
+
+// src/getWorkspaceDetails.ts
+async function getWorkspaceDetails({
+  root
+}) {
+  const { exists, absolute: workspaceRoot } = directoryInfo({
+    directory: root
+  });
+  if (!exists) {
+    throw new ConvertError(`Could not find directory at ${workspaceRoot}. Ensure the directory exists.`);
+  }
+  for (const { detect: detect4, read: read4 } of Object.values(managers_default)) {
+    if (await detect4({ workspaceRoot })) {
+      return read4({ workspaceRoot });
+    }
+  }
+  throw new ConvertError("Could not determine workspace manager. Add `packageManager` to `package.json` or ensure a lockfile is present.");
+}
+
+// src/commands/summary/index.ts
+async function summary(directory) {
+  const logger = new Logger();
+  logger.hero();
+  const answer = await import_inquirer.default.prompt({
+    type: "input",
+    name: "directoryInput",
+    message: "Where is the root of the repo?",
+    when: !directory,
+    default: ".",
+    validate: (directory2) => {
+      const { exists: exists2, absolute } = directoryInfo({ directory: directory2 });
+      if (exists2) {
+        return true;
+      } else {
+        return `Directory ${import_chalk3.default.dim(`(${absolute})`)} does not exist`;
+      }
+    },
+    filter: (directory2) => directory2.trim()
+  });
+  const { directoryInput: selectedDirectory = directory } = answer;
+  const { exists, absolute: root } = directoryInfo({
+    directory: selectedDirectory
+  });
+  if (!exists) {
+    console.error(`Directory ${import_chalk3.default.dim(`(${root})`)} does not exist`);
+    return process.exit(1);
+  }
+  const project = await getWorkspaceDetails({ root });
+  const numWorkspaces = project.workspaceData.workspaces.length;
+  const hasWorkspaces = numWorkspaces > 0;
+  const workspacesByDirectory = {};
+  project.workspaceData.workspaces.forEach((workspace) => {
+    const workspacePath = import_path6.default.relative(root, workspace.paths.root);
+    const rootDirectory = workspacePath.split(import_path6.default.sep)[0];
+    if (!workspacesByDirectory[rootDirectory]) {
+      workspacesByDirectory[rootDirectory] = [];
+    }
+    workspacesByDirectory[rootDirectory].push(workspace);
+  });
+  const renderWorkspace = (w) => {
+    return `${w.name} (${import_chalk3.default.italic(`./${import_path6.default.relative(root, w.paths.root)}`)})`;
+  };
+  const renderDirectory = ({
+    number,
+    directory: directory2,
+    workspaces
+  }) => {
+    logger.indented(2, `${number}. ${import_chalk3.default.bold(directory2)}`);
+    workspaces.forEach((workspace, idx) => {
+      logger.indented(3, `${idx + 1}. ${renderWorkspace(workspace)}`);
+    });
+  };
+  logger.header(`Repository Summary`);
+  logger.indented(1, `${import_chalk3.default.underline(project.name)}:`);
+  logger.indented(1, `Package Manager: ${import_chalk3.default.bold(import_chalk3.default.italic(project.packageManager))}`);
+  if (hasWorkspaces) {
+    logger.indented(1, `Workspaces (${import_chalk3.default.bold(numWorkspaces.toString())}):`);
+    Object.keys(workspacesByDirectory).forEach((directory2, idx) => {
+      renderDirectory({
+        number: idx + 1,
+        directory: directory2,
+        workspaces: workspacesByDirectory[directory2]
+      });
+    });
+    logger.blankLine();
+  }
+}
+
+// src/commands/convert/index.ts
+var import_inquirer2 = __toESM(require("inquirer"));
+var import_chalk5 = __toESM(require("chalk"));
+var import_turbo_utils = require("turbo-utils");
+
+// src/convert.ts
+var import_chalk4 = __toESM(require("chalk"));
+
+// src/install.ts
+var import_execa2 = __toESM(require("execa"));
+var import_ora = __toESM(require("ora"));
+var import_semver = require("semver");
+var PACKAGE_MANAGERS = {
+  npm: [
+    {
+      name: "npm",
+      template: "npm",
+      command: "npm",
+      installArgs: ["install"],
+      version: "latest",
+      executable: "npx",
+      semver: "*"
+    }
+  ],
+  pnpm: [
+    {
+      name: "pnpm6",
+      template: "pnpm",
+      command: "pnpm",
+      installArgs: ["install"],
+      version: "latest-6",
+      executable: "pnpx",
+      semver: "6.x"
+    },
+    {
+      name: "pnpm",
+      template: "pnpm",
+      command: "pnpm",
+      installArgs: ["install"],
+      version: "latest",
+      executable: "pnpm dlx",
+      semver: ">=7"
+    }
+  ],
+  yarn: [
+    {
+      name: "yarn",
+      template: "yarn",
+      command: "yarn",
+      installArgs: ["install"],
+      version: "1.x",
+      executable: "npx",
+      semver: "<2"
+    },
+    {
+      name: "berry",
+      template: "berry",
+      command: "yarn",
+      installArgs: ["install", "--no-immutable"],
+      version: "stable",
+      executable: "yarn dlx",
+      semver: ">=2"
+    }
+  ]
+};
+async function install(args) {
+  const { to, logger, options } = args;
+  let packageManager = PACKAGE_MANAGERS[to.name].find((manager) => (0, import_semver.satisfies)(to.version, manager.semver));
+  if (!packageManager) {
+    throw new ConvertError("Unsupported package manager version.");
+  }
+  logger.subStep(`running "${packageManager.command} ${packageManager.installArgs}"`);
+  if (!(options == null ? void 0 : options.dry)) {
+    let spinner;
+    if (options == null ? void 0 : options.interactive) {
+      spinner = (0, import_ora.default)({
+        text: "Installing dependencies...",
+        spinner: {
+          frames: logger.installerFrames()
+        }
+      }).start();
+    }
+    try {
+      await (0, import_execa2.default)(packageManager.command, packageManager.installArgs, {
+        cwd: args.project.paths.root
+      });
+      logger.subStep(`dependencies installed`);
+    } catch (err) {
+      logger.subStepFailure(`failed to install dependencies`);
+      throw err;
+    } finally {
+      if (spinner) {
+        spinner.stop();
+      }
+    }
+  }
+}
+var install_default = install;
+
+// src/convert.ts
+async function convert({
+  project,
+  to,
+  logger,
+  options
+}) {
+  logger.header(`Converting project from ${project.packageManager} to ${to.name}.`);
+  if (project.packageManager == to.name) {
+    throw new ConvertError("You are already using this package manager");
+  }
+  await managers_default[project.packageManager].remove({
+    project,
+    to,
+    logger,
+    options
+  });
+  await managers_default[to.name].create({ project, to, logger, options });
+  logger.mainStep("Installing dependencies");
+  if (!(options == null ? void 0 : options.skipInstall)) {
+    await managers_default[to.name].convertLock({ project, logger, options });
+    await install_default({ project, to, logger, options });
+  } else {
+    logger.subStep(import_chalk4.default.yellow("Skipping install"));
+  }
+  logger.mainStep(`Cleaning up ${project.packageManager} workspaces`);
+  await managers_default[project.packageManager].clean({ project, logger });
+}
+var convert_default = convert;
+
+// src/commands/convert/index.ts
+function isPackageManagerDisabled({
+  packageManager,
+  currentWorkspaceManger,
+  availablePackageManagers
+}) {
+  if (currentWorkspaceManger === packageManager) {
+    return "already in use";
+  }
+  if (!availablePackageManagers[packageManager].available) {
+    return "not installed";
+  }
+  return false;
+}
+async function convertCommand(directory, packageManager, options) {
+  const logger = new Logger(options);
+  logger.hero();
+  logger.header("Welcome, let's convert your project.");
+  logger.blankLine();
+  const directoryAnswer = await import_inquirer2.default.prompt({
+    type: "input",
+    name: "directoryInput",
+    message: "Where is the root of your repo?",
+    when: !directory,
+    default: ".",
+    validate: (directory2) => {
+      const { exists: exists2, absolute } = directoryInfo({ directory: directory2 });
+      if (exists2) {
+        return true;
+      } else {
+        return `Directory ${import_chalk5.default.dim(`(${absolute})`)} does not exist`;
+      }
+    },
+    filter: (directory2) => directory2.trim()
+  });
+  const { directoryInput: selectedDirectory = directory } = directoryAnswer;
+  const { exists, absolute: root } = directoryInfo({
+    directory: selectedDirectory
+  });
+  if (!exists) {
+    console.error(`Directory ${import_chalk5.default.dim(`(${root})`)} does not exist`);
+    return process.exit(1);
+  }
+  const [project, availablePackageManagers] = await Promise.all([
+    getWorkspaceDetails({ root }),
+    (0, import_turbo_utils.getAvailablePackageManagers)()
+  ]);
+  const packageManagerAnswer = await import_inquirer2.default.prompt({
+    name: "packageManagerInput",
+    type: "list",
+    message: `Convert from ${project.packageManager} workspaces to:`,
+    when: !packageManager || !Object.keys(availablePackageManagers).includes(packageManager),
+    choices: ["npm", "pnpm", "yarn"].map((p) => ({
+      name: `${p} workspaces`,
+      value: p,
+      disabled: isPackageManagerDisabled({
+        packageManager: p,
+        currentWorkspaceManger: project.packageManager,
+        availablePackageManagers
+      })
+    }))
+  });
+  const {
+    packageManagerInput: selectedPackageManager = packageManager
+  } = packageManagerAnswer;
+  await convert_default({
+    project,
+    to: {
+      name: selectedPackageManager,
+      version: availablePackageManagers[selectedPackageManager].version
+    },
+    logger,
+    options
+  });
+}
+
+// package.json
+var package_default = {
+  name: "@turbo/workspaces",
+  version: "0.0.1",
+  description: "Tools for working with package manager workspaces",
+  homepage: "https://turbo.build/repo",
+  license: "MPL-2.0",
+  repository: {
+    type: "git",
+    url: "https://github.com/vercel/turbo",
+    directory: "packages/turbo-workspaces"
+  },
+  bugs: {
+    url: "https://github.com/vercel/turbo/issues"
+  },
+  bin: "dist/cli.js",
+  main: "dist/index.js",
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "jest",
+    lint: "eslint src/**/*.ts",
+    "check-types": "tsc --noEmit"
+  },
+  dependencies: {
+    chalk: "2.4.2",
+    commander: "^10.0.0",
+    execa: "5.1.1",
+    "fast-glob": "^3.2.12",
+    "fs-extra": "^10.1.0",
+    "gradient-string": "^2.0.0",
+    inquirer: "^8.0.0",
+    "js-yaml": "^4.1.0",
+    ora: "4.1.1",
+    rimraf: "^3.0.2",
+    semver: "^7.3.5",
+    "turbo-utils": "workspace:*",
+    "update-check": "^1.5.4"
+  },
+  devDependencies: {
+    "@types/chalk-animation": "^1.6.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/gradient-string": "^1.1.2",
+    "@types/inquirer": "^7.3.1",
+    "@types/jest": "^27.4.0",
+    "@types/js-yaml": "^4.0.5",
+    "@types/node": "^16.11.12",
+    "@types/rimraf": "^3.0.2",
+    "@types/semver": "^7.3.9",
+    eslint: "^7.23.0",
+    jest: "^27.4.3",
+    semver: "^7.3.5",
+    "strip-ansi": "^6.0.1",
+    "ts-jest": "^27.1.1",
+    tsconfig: "workspace:*",
+    tsup: "^5.10.3",
+    "turbo-test-utils": "workspace:*",
+    typescript: "^4.5.5"
+  },
+  files: [
+    "dist"
+  ]
+};
+
+// src/cli.ts
+var workspacesCli = new import_commander.Command();
+workspacesCli.name("@turbo/workspaces").description("Tools for working with package manager workspaces").version(package_default.version, "-v, --version", "output the current version");
+workspacesCli.command("convert").description("Convert project between workspace managers").argument("[path]", "Project root").argument("[package-manager]", "Package manager to convert to").option("--skip-install", "Do not run a package manager install after conversion", false).option("--dry", "Dry run (no changes are made to files)", false).option("--force", "Bypass Git safety checks and forcibly run conversion", false).action(convertCommand);
+workspacesCli.command("summary").description("Display a summary of the specified project").argument("[path]", "Project root").action(summary);
+workspacesCli.parseAsync().catch((error) => {
+  console.log();
+  if (error instanceof ConvertError) {
+    console.log(import_chalk6.default.red(error.message));
+  } else {
+    console.log(import_chalk6.default.red("Unexpected error. Please report it as a bug:"));
+    console.log(error.message);
+  }
+  console.log();
+  process.exit(1);
+});