@turbo/codemod 1.7.1-canary.1 → 1.7.1-canary.2

package/dist/cli.js

@@ -0,0 +1,857 @@
+#!/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_chalk8 = __toESM(require("chalk"));
+var import_os4 = __toESM(require("os"));
+var import_commander = require("commander");
+
+// src/commands/migrate/index.ts
+var import_chalk5 = __toESM(require("chalk"));
+var import_os3 = __toESM(require("os"));
+var import_inquirer = __toESM(require("inquirer"));
+var import_child_process3 = require("child_process");
+
+// src/commands/migrate/steps/getCurrentVersion.ts
+var import_path2 = __toESM(require("path"));
+var import_fs_extra = require("fs-extra");
+
+// src/utils/getPackageManager.ts
+var import_find_up = __toESM(require("find-up"));
+var import_path = __toESM(require("path"));
+var cache = {};
+function getPackageManager({
+  directory
+}) {
+  const cwd = directory || process.cwd();
+  if (cache[cwd]) {
+    return cache[cwd];
+  }
+  const lockFile = import_find_up.default.sync(["yarn.lock", "pnpm-lock.yaml", "package-lock.json"], {
+    cwd
+  });
+  if (!lockFile) {
+    return;
+  }
+  switch (import_path.default.basename(lockFile)) {
+    case "yarn.lock":
+      cache[cwd] = "yarn";
+      break;
+    case "pnpm-lock.yaml":
+      cache[cwd] = "pnpm";
+      break;
+    case "package-lock.json":
+      cache[cwd] = "npm";
+      break;
+  }
+  return cache[cwd];
+}
+
+// src/commands/migrate/utils.ts
+var import_child_process = require("child_process");
+function exec(command, opts, fallback) {
+  try {
+    const rawResult = (0, import_child_process.execSync)(command, opts);
+    return rawResult.toString("utf8").trim();
+  } catch (err) {
+    return fallback || void 0;
+  }
+}
+
+// src/commands/migrate/steps/getCurrentVersion.ts
+function getCurrentVersion(directory, opts) {
+  const { from } = opts;
+  if (from) {
+    return from;
+  }
+  const turboVersionFromGlobal = exec(`turbo --version`, { cwd: directory });
+  if (turboVersionFromGlobal) {
+    return turboVersionFromGlobal;
+  }
+  const packageManager = getPackageManager({ directory });
+  if (packageManager) {
+    if (packageManager === "yarn") {
+      return exec(`yarn turbo --version`, { cwd: directory });
+    }
+    if (packageManager === "pnpm") {
+      return exec(`pnpm turbo --version`, { cwd: directory });
+    } else {
+      const turboBin = import_path2.default.join(directory, "node_modules", ".bin", "turbo");
+      if ((0, import_fs_extra.existsSync)(turboBin)) {
+        return exec(`${turboBin} --version`, { cwd: directory });
+      }
+    }
+  }
+  return void 0;
+}
+var getCurrentVersion_default = getCurrentVersion;
+
+// src/commands/migrate/steps/getLatestVersion.ts
+var import_axios = __toESM(require("axios"));
+var REGISTRY = "https://registry.npmjs.org";
+async function getPackageDetails({ packageName }) {
+  try {
+    const result = await import_axios.default.get(`${REGISTRY}/${packageName}`);
+    return result.data;
+  } catch (err) {
+    throw new Error(`Unable to fetch the latest version of ${packageName}`);
+  }
+}
+async function getLatestVersion({
+  to
+}) {
+  const packageDetails = await getPackageDetails({ packageName: "turbo" });
+  const versions = packageDetails["dist-tags"];
+  if (to) {
+    if (packageDetails[to]) {
+      return to;
+    } else {
+      throw new Error(`turbo@${to} does not exist`);
+    }
+  }
+  return versions.latest;
+}
+
+// src/commands/migrate/steps/getTransformsForMigration.ts
+var import_semver = require("semver");
+
+// src/utils/loadTransformers.ts
+var import_path3 = __toESM(require("path"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var transformerDirectory = process.env.NODE_ENV === "test" ? import_path3.default.join(__dirname, "../transforms") : import_path3.default.join(__dirname, "./transforms");
+function loadTransformers() {
+  const transformerFiles = import_fs_extra2.default.readdirSync(transformerDirectory);
+  return transformerFiles.map((transformerFilename) => {
+    const transformerPath = import_path3.default.join(transformerDirectory, transformerFilename);
+    try {
+      return require(transformerPath).default;
+    } catch (e) {
+      return void 0;
+    }
+  }).filter(Boolean);
+}
+
+// src/commands/migrate/steps/getTransformsForMigration.ts
+function getTransformsForMigration({
+  fromVersion,
+  toVersion
+}) {
+  const transforms2 = loadTransformers();
+  return transforms2.filter((transformer) => {
+    return (0, import_semver.gt)(transformer.introducedIn, fromVersion) && (0, import_semver.lte)(transformer.introducedIn, toVersion);
+  });
+}
+var getTransformsForMigration_default = getTransformsForMigration;
+
+// src/utils/checkGitStatus.ts
+var import_chalk = __toESM(require("chalk"));
+var import_is_git_clean = __toESM(require("is-git-clean"));
+function checkGitStatus({
+  directory,
+  force
+}) {
+  let clean = false;
+  let errorMessage = "Unable to determine if git directory is clean";
+  try {
+    clean = import_is_git_clean.default.sync(directory || process.cwd());
+    errorMessage = "Git directory is not clean";
+  } catch (err) {
+    if (err && err.stderr && err.stderr.indexOf("not a git repository") >= 0) {
+      clean = true;
+    }
+  }
+  if (!clean) {
+    if (force) {
+      console.log(`${import_chalk.default.yellow("WARNING")}: ${errorMessage}. Forcibly continuing...`);
+    } else {
+      console.log("Thank you for using @turbo/codemod!");
+      console.log(import_chalk.default.yellow("\nBut before we continue, please stash or commit your git changes."));
+      console.log("\nYou may use the --force flag to override this safety check.");
+      process.exit(1);
+    }
+  }
+}
+
+// src/utils/directoryInfo.ts
+var import_path4 = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+function directoryInfo({ directory }) {
+  const dir = import_path4.default.isAbsolute(directory) ? directory : import_path4.default.join(process.cwd(), directory);
+  return { exists: import_fs.default.existsSync(dir), absolute: dir };
+}
+
+// src/commands/migrate/steps/getTurboUpgradeCommand.ts
+var import_os = __toESM(require("os"));
+var import_path5 = __toESM(require("path"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_semver2 = require("semver");
+
+// src/utils/getPackageManagerVersion.ts
+var import_child_process2 = require("child_process");
+function getPackageManagerVersion(packageManager, root) {
+  switch (packageManager) {
+    case "yarn":
+      return (0, import_child_process2.execSync)("yarn --version", { cwd: root }).toString().trim();
+    case "pnpm":
+      return (0, import_child_process2.execSync)("pnpm --version", { cwd: root }).toString().trim();
+    case "npm":
+      return (0, import_child_process2.execSync)("npm --version", { cwd: root }).toString().trim();
+  }
+}
+
+// src/commands/migrate/steps/getTurboUpgradeCommand.ts
+function getGlobalBinaryPaths() {
+  return {
+    yarn: exec(`yarn global bin`, { cwd: import_os.default.homedir() }),
+    npm: exec(`npm bin --global`, { cwd: import_os.default.homedir() }),
+    pnpm: exec(`pnpm  bin --global`, { cwd: import_os.default.homedir() })
+  };
+}
+function getGlobalUpgradeCommand(packageManager, to = "latest") {
+  switch (packageManager) {
+    case "yarn":
+      return `yarn global add turbo@${to}`;
+    case "npm":
+      return `npm install turbo@${to} --global`;
+    case "pnpm":
+      return `pnpm install turbo@${to} --global`;
+  }
+}
+function getLocalUpgradeCommand({
+  packageManager,
+  packageManagerVersion,
+  installType,
+  isUsingWorkspaces,
+  to = "latest"
+}) {
+  const renderCommand = (command) => command.filter(Boolean).join(" ");
+  switch (packageManager) {
+    case "yarn":
+      if ((0, import_semver2.gte)(packageManagerVersion, "2.0.0")) {
+        return renderCommand([
+          "yarn",
+          "add",
+          `turbo@${to}`,
+          installType === "devDependencies" && "--dev"
+        ]);
+      } else {
+        return renderCommand([
+          "yarn",
+          "add",
+          `turbo@${to}`,
+          installType === "devDependencies" && "--dev",
+          isUsingWorkspaces && "-W"
+        ]);
+      }
+    case "npm":
+      return renderCommand([
+        "npm",
+        "install",
+        `turbo@${to}`,
+        installType === "devDependencies" && "--save-dev"
+      ]);
+    case "pnpm":
+      return renderCommand([
+        "pnpm",
+        "install",
+        `turbo@${to}`,
+        installType === "devDependencies" && "--save-dev",
+        isUsingWorkspaces && "-w"
+      ]);
+  }
+}
+function getInstallType({ directory }) {
+  const packageJsonPath = import_path5.default.join(directory, "package.json");
+  const pnpmWorkspaceConfig = import_path5.default.join(directory, "pnpm-workspace.yaml");
+  const isPnpmWorkspaces = import_fs_extra3.default.existsSync(pnpmWorkspaceConfig);
+  if (!import_fs_extra3.default.existsSync(packageJsonPath)) {
+    console.error(`Unable to find package.json at ${packageJsonPath}`);
+    return { installType: void 0, isUsingWorkspaces: void 0 };
+  }
+  const packageJson = import_fs_extra3.default.readJsonSync(packageJsonPath);
+  const isDevDependency = packageJson.devDependencies && "turbo" in packageJson.devDependencies;
+  const isDependency = packageJson.dependencies && "turbo" in packageJson.dependencies;
+  let isUsingWorkspaces = "workspaces" in packageJson || isPnpmWorkspaces;
+  if (isDependency || isDevDependency) {
+    return {
+      installType: isDependency ? "dependencies" : "devDependencies",
+      isUsingWorkspaces
+    };
+  }
+  return {
+    installType: void 0,
+    isUsingWorkspaces
+  };
+}
+function getTurboUpgradeCommand({
+  directory,
+  to
+}) {
+  const turboBinaryPathFromGlobal = exec(`turbo bin`, {
+    cwd: directory,
+    stdio: "pipe"
+  });
+  const packageManagerGlobalBinaryPaths = getGlobalBinaryPaths();
+  const globalPackageManager = Object.keys(packageManagerGlobalBinaryPaths).find((packageManager) => {
+    const packageManagerBinPath = packageManagerGlobalBinaryPaths[packageManager];
+    if (packageManagerBinPath && turboBinaryPathFromGlobal) {
+      return turboBinaryPathFromGlobal.includes(packageManagerBinPath);
+    }
+    return false;
+  });
+  if (turboBinaryPathFromGlobal && globalPackageManager) {
+    return getGlobalUpgradeCommand(globalPackageManager, to);
+  } else {
+    const packageManager = getPackageManager({ directory });
+    const { installType, isUsingWorkspaces } = getInstallType({ directory });
+    if (packageManager && installType) {
+      const packageManagerVersion = getPackageManagerVersion(packageManager, directory);
+      return getLocalUpgradeCommand({
+        packageManager,
+        packageManagerVersion,
+        installType,
+        isUsingWorkspaces,
+        to
+      });
+    }
+  }
+  return void 0;
+}
+
+// src/runner/Runner.ts
+var import_chalk4 = __toESM(require("chalk"));
+
+// src/runner/FileTransform.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_diff = require("diff");
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_os2 = __toESM(require("os"));
+var import_path6 = __toESM(require("path"));
+var FileTransform = class {
+  constructor(args) {
+    this.changes = [];
+    this.filePath = args.filePath;
+    this.rootPath = args.rootPath;
+    this.after = args.after;
+    this.error = args.error;
+    if (args.before === void 0) {
+      try {
+        if (import_path6.default.extname(args.filePath) === ".json") {
+          this.before = import_fs_extra4.default.readJsonSync(args.filePath);
+        } else {
+          this.before = import_fs_extra4.default.readFileSync(args.filePath);
+        }
+      } catch (err) {
+        this.before = "";
+      }
+    } else if (args.before === null) {
+      this.before = "";
+    } else {
+      this.before = args.before;
+    }
+    if (args.after) {
+      if (typeof this.before === "object" || typeof args.after === "object") {
+        this.changes = (0, import_diff.diffJson)(this.before, args.after);
+      } else {
+        this.changes = (0, import_diff.diffLines)(this.before, args.after);
+      }
+    } else {
+      this.changes = [];
+    }
+  }
+  fileName() {
+    return import_path6.default.relative(this.rootPath, this.filePath);
+  }
+  write() {
+    if (this.after) {
+      if (typeof this.after === "object") {
+        import_fs_extra4.default.writeJsonSync(this.filePath, this.after, { spaces: 2 });
+      } else {
+        import_fs_extra4.default.writeFileSync(this.filePath, this.after);
+      }
+    }
+  }
+  additions() {
+    return this.changes.filter((c) => c.added).length;
+  }
+  deletions() {
+    return this.changes.filter((c) => c.removed).length;
+  }
+  hasChanges() {
+    return this.additions() > 0 || this.deletions() > 0;
+  }
+  log(args) {
+    if (args.diff) {
+      this.changes.forEach((part) => {
+        if (part.added) {
+          process.stdout.write(import_chalk2.default.green(part.value));
+        } else if (part.removed) {
+          process.stdout.write(import_chalk2.default.red(part.value));
+        } else {
+          process.stdout.write(import_chalk2.default.dim(part.value));
+        }
+      });
+      console.log(import_os2.default.EOL);
+    } else {
+      console.log(this.after);
+    }
+  }
+};
+
+// src/utils/logger.ts
+var import_chalk3 = __toESM(require("chalk"));
+var Logger = class {
+  constructor(args) {
+    this.transform = args.transformer;
+    this.dry = args.dry;
+  }
+  modified(...args) {
+    console.log(import_chalk3.default.green(` MODIFIED `), ...args, this.dry ? import_chalk3.default.dim(`(dry run)`) : "");
+  }
+  unchanged(...args) {
+    console.log(import_chalk3.default.gray(` UNCHANGED `), ...args, this.dry ? import_chalk3.default.dim(`(dry run)`) : "");
+  }
+  skipped(...args) {
+    console.log(import_chalk3.default.yellow(` SKIPPED `), ...args, this.dry ? import_chalk3.default.dim(`(dry run)`) : "");
+  }
+  error(...args) {
+    console.log(import_chalk3.default.red(` ERROR `), ...args, this.dry ? import_chalk3.default.dim(`(dry run)`) : "");
+  }
+  info(...args) {
+    console.log(import_chalk3.default.bold(` INFO `), ...args, this.dry ? import_chalk3.default.dim(`(dry run)`) : "");
+  }
+};
+
+// src/runner/Runner.ts
+var Runner = class {
+  constructor(options) {
+    this.modifications = {};
+    this.transform = options.transformer;
+    this.rootPath = options.rootPath;
+    this.dry = options.dry;
+    this.print = options.print;
+    this.logger = new Logger(options);
+  }
+  abortTransform(args) {
+    this.logger.error(args.reason);
+    return {
+      fatalError: new Error(args.reason),
+      changes: args.changes || {}
+    };
+  }
+  modifyFile(args) {
+    this.modifications[args.filePath] = new FileTransform({
+      rootPath: this.rootPath,
+      ...args
+    });
+  }
+  finish() {
+    const results = { changes: {} };
+    Object.keys(this.modifications).forEach((filePath) => {
+      const mod = this.modifications[filePath];
+      const result = {
+        action: "unchanged",
+        additions: mod.additions(),
+        deletions: mod.deletions()
+      };
+      if (mod.hasChanges()) {
+        if (this.dry) {
+          result.action = "skipped";
+          this.logger.skipped(import_chalk4.default.dim(mod.fileName()));
+        } else {
+          try {
+            mod.write();
+            result.action = "modified";
+            this.logger.modified(import_chalk4.default.bold(mod.fileName()));
+          } catch (err) {
+            let message = "Unknown error";
+            if (err instanceof Error) {
+              message = err.message;
+            }
+            result.error = new Error(message);
+            result.action = "error";
+            this.logger.error(mod.fileName(), message);
+          }
+        }
+        if (this.print) {
+          mod.log({ diff: true });
+        }
+      } else {
+        this.logger.unchanged(import_chalk4.default.dim(mod.fileName()));
+      }
+      results.changes[mod.fileName()] = result;
+    });
+    const encounteredError = Object.keys(results.changes).some((fileName) => {
+      return results.changes[fileName].action === "error";
+    });
+    if (encounteredError) {
+      return this.abortTransform({
+        reason: "Encountered an error while transforming files",
+        changes: results.changes
+      });
+    }
+    return results;
+  }
+  static logResults(results) {
+    const changedFiles = Object.keys(results.changes);
+    console.log();
+    if (changedFiles.length > 0) {
+      console.log(import_chalk4.default.bold(`Results:`));
+      const table = {};
+      changedFiles.forEach((fileName) => {
+        var _a;
+        const fileChanges = results.changes[fileName];
+        table[fileName] = {
+          action: fileChanges.action,
+          additions: fileChanges.additions,
+          deletions: fileChanges.deletions,
+          error: ((_a = fileChanges.error) == null ? void 0 : _a.message) || "None"
+        };
+      });
+      console.table(table);
+      console.log();
+    }
+  }
+};
+var Runner_default = Runner;
+
+// src/utils/looksLikeRepo.ts
+var import_path7 = __toESM(require("path"));
+var import_fs_extra5 = require("fs-extra");
+var HINTS = ["package.json", "turbo.json", ".git"];
+function looksLikeRepo({
+  directory
+}) {
+  return HINTS.some((hint) => (0, import_fs_extra5.existsSync)(import_path7.default.join(directory, hint)));
+}
+
+// src/commands/migrate/index.ts
+function endMigration({
+  message,
+  success
+}) {
+  if (success) {
+    console.log(import_chalk5.default.bold(import_chalk5.default.green("Migration completed")));
+    if (message) {
+      console.log(message);
+    }
+    return process.exit(0);
+  }
+  console.log(import_chalk5.default.bold(import_chalk5.default.red("Migration failed")));
+  if (message) {
+    console.log(message);
+  }
+  return process.exit(1);
+}
+async function migrate(directory, options) {
+  if (!options.dry) {
+    checkGitStatus({ directory, force: options.force });
+  }
+  const answers = await import_inquirer.default.prompt([
+    {
+      type: "input",
+      name: "directoryInput",
+      message: "Where is the root of the repo to migrate?",
+      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 } = answers;
+  const { exists, absolute: root } = directoryInfo({
+    directory: selectedDirectory
+  });
+  if (!exists) {
+    return endMigration({
+      success: false,
+      message: `Directory ${import_chalk5.default.dim(`(${root})`)} does not exist`
+    });
+  }
+  if (!looksLikeRepo({ directory: root })) {
+    return endMigration({
+      success: false,
+      message: `Directory (${import_chalk5.default.dim(root)}) does not appear to be a repository`
+    });
+  }
+  const fromVersion = getCurrentVersion_default(selectedDirectory, options);
+  if (!fromVersion) {
+    return endMigration({
+      success: false,
+      message: `Unable to infer the version of turbo being used by ${directory}`
+    });
+  }
+  let toVersion = options.to;
+  try {
+    toVersion = await getLatestVersion(options);
+  } catch (err) {
+    let message = "UNKNOWN_ERROR";
+    if (err instanceof Error) {
+      message = err.message;
+    }
+    return endMigration({
+      success: false,
+      message
+    });
+  }
+  if (!toVersion) {
+    return endMigration({
+      success: false,
+      message: `Unable to fetch the latest version of turbo`
+    });
+  }
+  if (fromVersion === toVersion) {
+    return endMigration({
+      success: true,
+      message: `Nothing to do, current version (${import_chalk5.default.bold(fromVersion)}) is the same as the requested version (${import_chalk5.default.bold(toVersion)})`
+    });
+  }
+  const codemods = getTransformsForMigration_default({ fromVersion, toVersion });
+  if (codemods.length === 0) {
+    console.log(`No codemods required to migrate from ${fromVersion} to ${toVersion}`, import_os3.default.EOL);
+  }
+  console.log(`Upgrading turbo from ${import_chalk5.default.bold(fromVersion)} to ${import_chalk5.default.bold(toVersion)} (${codemods.length === 0 ? "no codemods required" : `${codemods.length} required codemod${codemods.length === 1 ? "" : "s"}`})`, import_os3.default.EOL);
+  const results = codemods.map((codemod, idx) => {
+    console.log(`(${idx + 1}/${codemods.length}) ${import_chalk5.default.bold(`Running ${codemod.value}`)}`);
+    const result = codemod.transformer({ root: selectedDirectory, options });
+    Runner_default.logResults(result);
+    return result;
+  });
+  const hasTransformError = results.some((result) => result.fatalError || Object.keys(result.changes).some((key) => result.changes[key].error));
+  if (hasTransformError) {
+    return endMigration({
+      success: false,
+      message: `Could not complete migration due to codemod errors. Please fix the errors and try again.`
+    });
+  }
+  const upgradeCommand = getTurboUpgradeCommand({
+    directory: selectedDirectory,
+    to: options.to
+  });
+  if (!upgradeCommand) {
+    return endMigration({
+      success: false,
+      message: "Unable to determine upgrade command"
+    });
+  }
+  if (options.install) {
+    if (options.dry) {
+      console.log(`Upgrading turbo with ${import_chalk5.default.bold(upgradeCommand)} ${import_chalk5.default.dim("(dry run)")}`, import_os3.default.EOL);
+    } else {
+      console.log(`Upgrading turbo with ${import_chalk5.default.bold(upgradeCommand)}`, import_os3.default.EOL);
+      (0, import_child_process3.execSync)(upgradeCommand, { cwd: selectedDirectory });
+    }
+  } else {
+    console.log(`Upgrade turbo with ${import_chalk5.default.bold(upgradeCommand)}`, import_os3.default.EOL);
+  }
+  endMigration({ success: true });
+}
+
+// src/commands/transform/index.ts
+var import_chalk6 = __toESM(require("chalk"));
+var import_inquirer2 = __toESM(require("inquirer"));
+async function transform(transform2, directory, options) {
+  const transforms2 = loadTransformers();
+  if (options.list) {
+    console.log(transforms2.map((transform3) => `- ${import_chalk6.default.cyan(transform3.value)}`).join("\n"));
+    return process.exit(0);
+  }
+  if (!options.dry) {
+    checkGitStatus({ directory, force: options.force });
+  }
+  const answers = await import_inquirer2.default.prompt([
+    {
+      type: "input",
+      name: "directoryInput",
+      message: "Where is the root of the repo where the transform should run?",
+      when: !directory,
+      default: ".",
+      validate: (directory2) => {
+        const { exists: exists2, absolute } = directoryInfo({ directory: directory2 });
+        if (exists2) {
+          return true;
+        } else {
+          return `Directory ${import_chalk6.default.dim(`(${absolute})`)} does not exist`;
+        }
+      },
+      filter: (directory2) => directory2.trim()
+    },
+    {
+      type: "list",
+      name: "transformerInput",
+      message: "Which transform would you like to apply?",
+      when: !transform2,
+      pageSize: transforms2.length,
+      choices: transforms2
+    }
+  ]);
+  const {
+    directoryInput: selectedDirectory = directory,
+    transformerInput: selectedTransformer = transform2
+  } = answers;
+  const { exists, absolute: root } = directoryInfo({
+    directory: selectedDirectory
+  });
+  if (!exists) {
+    console.error(`Directory ${import_chalk6.default.dim(`(${root})`)} does not exist`);
+    return process.exit(1);
+  }
+  const transformKeys = transforms2.map((transform3) => transform3.value);
+  const transformData = transforms2.find((transform3) => transform3.value === selectedTransformer);
+  if (!transformData) {
+    console.error(`Invalid transform choice ${import_chalk6.default.dim(`(${transform2})`)}, pick one of:`);
+    console.error(transformKeys.map((key) => `- ${key}`).join("\n"));
+    return process.exit(1);
+  }
+  const result = transformData.transformer({
+    root,
+    options
+  });
+  if (result.fatalError) {
+    return process.exit(1);
+  }
+  Runner_default.logResults(result);
+}
+
+// src/utils/notifyUpdate.ts
+var import_chalk7 = __toESM(require("chalk"));
+var import_update_check = __toESM(require("update-check"));
+
+// package.json
+var package_default = {
+  name: "@turbo/codemod",
+  version: "1.7.1-canary.2",
+  description: "Provides Codemod transformations to help upgrade your Turborepo codebase when a feature is deprecated.",
+  homepage: "https://turbo.build/repo",
+  license: "MPL-2.0",
+  repository: {
+    type: "git",
+    url: "https://github.com/vercel/turbo",
+    directory: "packages/turbo-codemod"
+  },
+  bugs: {
+    url: "https://github.com/vercel/turbo/issues"
+  },
+  bin: "dist/index.js",
+  scripts: {
+    build: "tsup",
+    test: "jest",
+    lint: "eslint src/**/*.ts",
+    "check-types": "tsc --noEmit",
+    "add-transformer": "plop"
+  },
+  dependencies: {
+    axios: "0.27.2",
+    chalk: "2.4.2",
+    commander: "^9.5.0",
+    diff: "^5.1.0",
+    "find-up": "4.1.0",
+    "fs-extra": "^10.0.0",
+    "gradient-string": "^2.0.0",
+    inquirer: "^8.2.4",
+    "inquirer-file-tree-selection-prompt": "^1.0.19",
+    "is-git-clean": "^1.1.0",
+    ora: "4.1.1",
+    semver: "^7.3.7",
+    "turbo-utils": "workspace:*",
+    "update-check": "^1.5.4"
+  },
+  devDependencies: {
+    "@types/chalk-animation": "^1.6.0",
+    "@types/diff": "^5.0.2",
+    "@types/fs-extra": "^9.0.13",
+    "@types/gradient-string": "^1.1.2",
+    "@types/inquirer": "^8.2.0",
+    "@types/jest": "^27.4.0",
+    "@types/node": "^16.11.12",
+    "@types/semver": "^7.3.9",
+    "@types/uuid": "^9.0.0",
+    deepmerge: "^4.2.2",
+    eslint: "^7.23.0",
+    jest: "^27.4.3",
+    plop: "^3.1.1",
+    semver: "^7.3.5",
+    "ts-jest": "^27.1.1",
+    tsconfig: "workspace:*",
+    tsup: "^5.10.3",
+    "turbo-types": "workspace:*",
+    typescript: "^4.5.5",
+    uuid: "^9.0.0"
+  },
+  files: [
+    "dist"
+  ],
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/utils/notifyUpdate.ts
+var update = (0, import_update_check.default)(package_default).catch(() => null);
+async function notifyUpdate() {
+  try {
+    const res = await update;
+    if (res == null ? void 0 : res.latest) {
+      const ws = getPackageManager(process.cwd());
+      console.log();
+      console.log(import_chalk7.default.yellow.bold("A new version of `@turbo/codemod` is available!"));
+      console.log("You can update by running: " + import_chalk7.default.cyan(ws === "yarn" ? "yarn global add @turbo/codemod" : ws === "pnpm" ? "pnpm i -g @turbo/codemod" : "npm i -g @turbo/codemod"));
+      console.log();
+    }
+    process.exit();
+  } catch (_e) {
+  }
+}
+
+// src/cli.ts
+var transforms = loadTransformers();
+var codemodCli = new import_commander.Command();
+codemodCli.name("@turbo/codemod").description("Codemod transformations to help upgrade your Turborepo codebase when a feature is deprecated.").version(package_default.version, "-v, --version", "output the current version");
+codemodCli.command("migrate").aliases(["update", "upgrade"]).description("Migrate a project to the latest version of Turborepo").argument("[path]", "Directory where the transforms should be applied").option("--from <version>", "Specify the version to migrate from (default: current version)").option("--to <version>", "Specify the version to migrate to (default: latest)").option("--install", "Install new version of turbo after migration", true).option("--force", "Bypass Git safety checks and forcibly run codemods", false).option("--dry", "Dry run (no changes are made to files)", false).option("--print", "Print transformed files to your terminal", false).action(migrate);
+codemodCli.command("transform").description("Apply a single code transformation to a project").argument("[transform]", "The transformer to run").argument("[path]", "Directory where the transforms should be applied").option("--force", "Bypass Git safety checks and forcibly run codemods", false).option("--list", "List all available transforms", false).option("--dry", "Dry run (no changes are made to files)", false).option("--print", "Print transformed files to your terminal", false).action(transform);
+codemodCli.showHelpAfterError(true);
+codemodCli.addHelpText("beforeAll", (context) => {
+  try {
+    const transformKeys = transforms.map((transform2) => transform2.value);
+    if (context.command.args.length >= 1 && transformKeys.includes(context.command.args[0])) {
+      return `Transforms must be run with the "transform" command.${import_os4.default.EOL}Try: ${import_chalk8.default.bold(`transform ${context.command.args[0]}`)}${import_os4.default.EOL}`;
+    }
+  } catch (e) {
+    return "";
+  }
+  return "";
+});
+codemodCli.parseAsync().then(notifyUpdate).catch(async (reason) => {
+  console.log();
+  if (reason.command) {
+    console.log(`  ${import_chalk8.default.cyan(reason.command)} has failed.`);
+  } else {
+    console.log(import_chalk8.default.red("Unexpected error. Please report it as a bug:"));
+    console.log(reason);
+  }
+  console.log();
+  await notifyUpdate();
+  process.exit(1);
+});