@backstage/cli 0.27.1 → 0.28.0-next.0

package/dist/cjs/{new-DJUBFwiF.cjs.js → new-C0D_k25O.cjs.js}

@@ -7,25 +7,22 @@ var chalk = require('chalk');
 var inquirer = require('inquirer');
 var camelCase = require('lodash/camelCase');
 var upperFirst = require('lodash/upperFirst');
-var index = require('./index-DmUbBCFk.cjs.js');
-var codeowners = require('./codeowners-FKKtpciN.cjs.js');
-var tasks = require('./tasks-DtAiMv5G.cjs.js');
-var Lockfile = require('./Lockfile-B4mqBkH6.cjs.js');
+var index = require('./index-v57xnvgT.cjs.js');
+var handlebars = require('handlebars');
+var ora = require('ora');
+var util = require('util');
+var recursive = require('recursive-readdir');
+var child_process = require('child_process');
+var errors = require('@backstage/errors');
+var yarn = require('./yarn-6FNAgNBK.cjs.js');
 require('minimatch');
 require('@manypkg/get-packages');
-require('./yarn-Ukl9MOS0.cjs.js');
-require('./run-CSt1n0F1.cjs.js');
+require('./run-HW3lfDbM.cjs.js');
 var partition = require('lodash/partition');
 var cliNode = require('@backstage/cli-node');
-var errors = require('@backstage/errors');
 require('commander');
 require('semver');
 require('@backstage/cli-common');
-require('handlebars');
-require('ora');
-require('util');
-require('recursive-readdir');
-require('child_process');
 require('@yarnpkg/parsers');
 require('@yarnpkg/lockfile');
 
@@ -33,16 +30,258 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 var os__default = /*#__PURE__*/_interopDefaultCompat(os);
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
 var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
 var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
 var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
 var upperFirst__default = /*#__PURE__*/_interopDefaultCompat(upperFirst);
+var handlebars__default = /*#__PURE__*/_interopDefaultCompat(handlebars);
+var ora__default = /*#__PURE__*/_interopDefaultCompat(ora);
+var recursive__default = /*#__PURE__*/_interopDefaultCompat(recursive);
 var partition__default = /*#__PURE__*/_interopDefaultCompat(partition);
 
+const TEAM_ID_RE = /^@[-\w]+\/[-\w]+$/;
+const USER_ID_RE = /^@[-\w]+$/;
+const EMAIL_RE = /^[^@]+@[-.\w]+\.[-\w]+$/i;
+const DEFAULT_OWNER = "@backstage/maintainers";
+async function getCodeownersFilePath(rootDir) {
+  const possiblePaths = [
+    path__default.default.join(rootDir, ".github", "CODEOWNERS"),
+    path__default.default.join(rootDir, ".gitlab", "CODEOWNERS"),
+    path__default.default.join(rootDir, "docs", "CODEOWNERS"),
+    path__default.default.join(rootDir, "CODEOWNERS")
+  ];
+  for (const p of possiblePaths) {
+    if (await fs__default.default.pathExists(p)) {
+      return p;
+    }
+  }
+  return void 0;
+}
+function isValidSingleOwnerId(id) {
+  if (!id || typeof id !== "string") {
+    return false;
+  }
+  return TEAM_ID_RE.test(id) || USER_ID_RE.test(id) || EMAIL_RE.test(id);
+}
+function parseOwnerIds(spaceSeparatedOwnerIds) {
+  if (!spaceSeparatedOwnerIds || typeof spaceSeparatedOwnerIds !== "string") {
+    return void 0;
+  }
+  const ids = spaceSeparatedOwnerIds.split(" ").filter(Boolean);
+  if (!ids.every(isValidSingleOwnerId)) {
+    return void 0;
+  }
+  return ids;
+}
+async function addCodeownersEntry(ownedPath, ownerStr, codeownersFilePath) {
+  const ownerIds = parseOwnerIds(ownerStr);
+  if (!ownerIds || ownerIds.length === 0) {
+    return false;
+  }
+  let filePath = codeownersFilePath;
+  if (!filePath) {
+    filePath = await getCodeownersFilePath(index.paths.targetRoot);
+    if (!filePath) {
+      return false;
+    }
+  }
+  const allLines = (await fs__default.default.readFile(filePath, "utf8")).split("\n");
+  const commentLines = [];
+  for (const line of allLines) {
+    if (line[0] !== "#") {
+      break;
+    }
+    commentLines.push(line);
+  }
+  const oldDeclarationEntries = allLines.filter((line) => line[0] !== "#").map((line) => line.split(/\s+/).filter(Boolean)).filter((tokens) => tokens.length >= 2).map((tokens) => ({
+    ownedPath: tokens[0],
+    ownerIds: tokens.slice(1)
+  }));
+  const newDeclarationEntries = oldDeclarationEntries.filter((entry) => entry.ownedPath !== "*").concat([{ ownedPath, ownerIds }]).sort((l1, l2) => l1.ownedPath.localeCompare(l2.ownedPath));
+  newDeclarationEntries.unshift({
+    ownedPath: "*",
+    ownerIds: [DEFAULT_OWNER]
+  });
+  const longestOwnedPath = newDeclarationEntries.reduce(
+    (length, entry) => Math.max(length, entry.ownedPath.length),
+    0
+  );
+  const newDeclarationLines = newDeclarationEntries.map((entry) => {
+    const entryPath = entry.ownedPath + " ".repeat(longestOwnedPath - entry.ownedPath.length);
+    return [entryPath, ...entry.ownerIds].join(" ");
+  });
+  const newLines = [...commentLines, "", ...newDeclarationLines, ""];
+  await fs__default.default.writeFile(filePath, newLines.join("\n"), "utf8");
+  return true;
+}
+
 function createFactory(config) {
   return config;
 }
 
+const exec = util.promisify(child_process.exec);
+const TASK_NAME_MAX_LENGTH = 14;
+class Task {
+  static log(name = "") {
+    process.stderr.write(`${chalk__default.default.green(name)}
+`);
+  }
+  static error(message = "") {
+    process.stderr.write(`
+${chalk__default.default.red(message)}
+
+`);
+  }
+  static section(name) {
+    const title = chalk__default.default.green(`${name}:`);
+    process.stderr.write(`
+ ${title}
+`);
+  }
+  static exit(code = 0) {
+    process.exit(code);
+  }
+  static async forItem(task, item, taskFunc) {
+    const paddedTask = chalk__default.default.green(task.padEnd(TASK_NAME_MAX_LENGTH));
+    const spinner = ora__default.default({
+      prefixText: chalk__default.default.green(`  ${paddedTask}${chalk__default.default.cyan(item)}`),
+      spinner: "arc",
+      color: "green"
+    }).start();
+    try {
+      const result = await taskFunc();
+      spinner.succeed();
+      return result;
+    } catch (error) {
+      spinner.fail();
+      throw error;
+    }
+  }
+  static async forCommand(command, options) {
+    try {
+      await Task.forItem("executing", command, async () => {
+        await exec(command, { cwd: options?.cwd });
+      });
+    } catch (error) {
+      errors.assertError(error);
+      if (error.stderr) {
+        process.stderr.write(error.stderr);
+      }
+      if (error.stdout) {
+        process.stdout.write(error.stdout);
+      }
+      if (options?.optional) {
+        Task.error(`Warning: Failed to execute command ${chalk__default.default.cyan(command)}`);
+      } else {
+        throw new Error(
+          `Failed to execute command '${chalk__default.default.cyan(command)}', ${error}`
+        );
+      }
+    }
+  }
+}
+async function templatingTask(templateDir, destinationDir, context, versionProvider, isMonoRepo) {
+  const files = await recursive__default.default(templateDir).catch((error) => {
+    throw new Error(`Failed to read template directory: ${error.message}`);
+  });
+  for (const file of files) {
+    const destinationFile = file.replace(templateDir, destinationDir);
+    await fs__default.default.ensureDir(path.dirname(destinationFile));
+    if (file.endsWith(".hbs")) {
+      await Task.forItem("templating", path.basename(file), async () => {
+        const destination = destinationFile.replace(/\.hbs$/, "");
+        const template = await fs__default.default.readFile(file);
+        const compiled = handlebars__default.default.compile(template.toString(), {
+          strict: true
+        });
+        const contents = compiled(
+          { name: path.basename(destination), ...context },
+          {
+            helpers: {
+              versionQuery(name, versionHint) {
+                return versionProvider(
+                  name,
+                  typeof versionHint === "string" ? versionHint : void 0
+                );
+              }
+            }
+          }
+        );
+        await fs__default.default.writeFile(destination, contents).catch((error) => {
+          throw new Error(
+            `Failed to create file: ${destination}: ${error.message}`
+          );
+        });
+      });
+    } else {
+      if (isMonoRepo && file.match("tsconfig.json")) {
+        continue;
+      }
+      await Task.forItem("copying", path.basename(file), async () => {
+        await fs__default.default.copyFile(file, destinationFile).catch((error) => {
+          const destination = destinationFile;
+          throw new Error(
+            `Failed to copy file to ${destination} : ${error.message}`
+          );
+        });
+      });
+    }
+  }
+}
+async function addPackageDependency(path, options) {
+  try {
+    const pkgJson = await fs__default.default.readJson(path);
+    const normalize = (obj) => {
+      if (Object.keys(obj).length === 0) {
+        return void 0;
+      }
+      return Object.fromEntries(
+        Object.keys(obj).sort().map((key) => [key, obj[key]])
+      );
+    };
+    pkgJson.dependencies = normalize({
+      ...pkgJson.dependencies,
+      ...options.dependencies
+    });
+    pkgJson.devDependencies = normalize({
+      ...pkgJson.devDependencies,
+      ...options.devDependencies
+    });
+    pkgJson.peerDependencies = normalize({
+      ...pkgJson.peerDependencies,
+      ...options.peerDependencies
+    });
+    await fs__default.default.writeJson(path, pkgJson, { spaces: 2 });
+  } catch (error) {
+    throw new Error(`Failed to add package dependencies, ${error}`);
+  }
+}
+async function addToBackend(name, options) {
+  if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/backend"))) {
+    await Task.forItem("backend", `adding ${options.type}`, async () => {
+      const backendFilePath = index.paths.resolveTargetRoot(
+        "packages/backend/src/index.ts"
+      );
+      if (!await fs__default.default.pathExists(backendFilePath)) {
+        return;
+      }
+      const content = await fs__default.default.readFile(backendFilePath, "utf8");
+      const lines = content.split("\n");
+      const backendAddLine = `backend.add(import('${name}'));`;
+      const backendStartIndex = lines.findIndex(
+        (line) => line.match(/backend.start/)
+      );
+      if (backendStartIndex !== -1) {
+        const [indentation] = lines[backendStartIndex].match(/^\s*/);
+        lines.splice(backendStartIndex, 0, `${indentation}${backendAddLine}`);
+        const newContent = lines.join("\n");
+        await fs__default.default.writeFile(backendFilePath, newContent, "utf8");
+      }
+    });
+  }
+}
+
 function pluginIdPrompt() {
   return {
     type: "input",
@@ -83,7 +322,7 @@ function ownerPrompt() {
       if (!value) {
         return true;
       }
-      const ownerIds = codeowners.parseOwnerIds(value);
+      const ownerIds = parseOwnerIds(value);
       if (!ownerIds) {
         return "The owner must be a space separated list of team names (e.g. @org/team-name), usernames (e.g. @username), or the email addresses (e.g. user@example.com).";
       }
@@ -96,12 +335,12 @@ async function executePluginPackageTemplate(ctx, options) {
   const { targetDir } = options;
   let lockfile;
   try {
-    lockfile = await Lockfile.Lockfile.load(index.paths.resolveTargetRoot("yarn.lock"));
+    lockfile = await yarn.Lockfile.load(index.paths.resolveTargetRoot("yarn.lock"));
   } catch {
   }
-  tasks.Task.section("Checking Prerequisites");
+  Task.section("Checking Prerequisites");
   const shortPluginDir = path.relative(index.paths.targetRoot, targetDir);
-  await tasks.Task.forItem("availability", shortPluginDir, async () => {
+  await Task.forItem("availability", shortPluginDir, async () => {
     if (await fs__default.default.pathExists(targetDir)) {
       throw new Error(
         `A package with the same plugin ID already exists at ${chalk__default.default.cyan(
@@ -110,11 +349,11 @@ async function executePluginPackageTemplate(ctx, options) {
       );
     }
   });
-  const tempDir = await tasks.Task.forItem("creating", "temp dir", async () => {
+  const tempDir = await Task.forItem("creating", "temp dir", async () => {
     return await ctx.createTemporaryDirectory("backstage-create");
   });
-  tasks.Task.section("Executing Template");
-  await tasks.templatingTask(
+  Task.section("Executing Template");
+  await templatingTask(
     index.paths.resolveOwn("templates", options.templateName),
     tempDir,
     options.values,
@@ -126,8 +365,8 @@ async function executePluginPackageTemplate(ctx, options) {
     const pkgJson = await fs__default.default.readJson(pkgJsonPath);
     await fs__default.default.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
   }
-  tasks.Task.section("Installing");
-  await tasks.Task.forItem("moving", shortPluginDir, async () => {
+  Task.section("Installing");
+  await Task.forItem("moving", shortPluginDir, async () => {
     await fs__default.default.move(tempDir, targetDir).catch((error) => {
       throw new Error(
         `Failed to move package from ${tempDir} to ${targetDir}, ${error.message}`
@@ -153,7 +392,7 @@ const frontendPlugin = createFactory({
   name: "plugin",
   description: "A new frontend plugin",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
   async create(options, ctx) {
@@ -164,8 +403,8 @@ const frontendPlugin = createFactory({
       plugin: true
     });
     const extensionName = `${upperFirst__default.default(camelCase__default.default(id))}Page`;
-    tasks.Task.log();
-    tasks.Task.log(`Creating frontend plugin ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating frontend plugin ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", id) : index.paths.resolveTargetRoot(`backstage-plugin-${id}`);
     await executePluginPackageTemplate(ctx, {
       targetDir,
@@ -182,8 +421,8 @@ const frontendPlugin = createFactory({
       }
     });
     if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/app"))) {
-      await tasks.Task.forItem("app", "adding dependency", async () => {
-        await tasks.addPackageDependency(
+      await Task.forItem("app", "adding dependency", async () => {
+        await addPackageDependency(
           index.paths.resolveTargetRoot("packages/app/package.json"),
           {
             dependencies: {
@@ -192,7 +431,7 @@ const frontendPlugin = createFactory({
           }
         );
       });
-      await tasks.Task.forItem("app", "adding import", async () => {
+      await Task.forItem("app", "adding import", async () => {
         const pluginsFilePath = index.paths.resolveTargetRoot(
           "packages/app/src/App.tsx"
         );
@@ -223,10 +462,10 @@ const frontendPlugin = createFactory({
       });
     }
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/plugins/${id}`, options.owner);
+      await addCodeownersEntry(`/plugins/${id}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -237,7 +476,7 @@ const backendPlugin = createFactory({
   name: "backend-plugin",
   description: "A new backend plugin",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
   async create(options, ctx) {
@@ -248,8 +487,8 @@ const backendPlugin = createFactory({
       scope: ctx.scope,
       plugin: true
     });
-    tasks.Task.log();
-    tasks.Task.log(`Creating backend plugin ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating backend plugin ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", pluginId) : index.paths.resolveTargetRoot(`backstage-plugin-${pluginId}`);
     await executePluginPackageTemplate(ctx, {
       targetDir,
@@ -265,8 +504,8 @@ const backendPlugin = createFactory({
       }
     });
     if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/backend"))) {
-      await tasks.Task.forItem("backend", "adding dependency", async () => {
-        await tasks.addPackageDependency(
+      await Task.forItem("backend", "adding dependency", async () => {
+        await addPackageDependency(
           index.paths.resolveTargetRoot("packages/backend/package.json"),
           {
             dependencies: {
@@ -276,14 +515,14 @@ const backendPlugin = createFactory({
         );
       });
     }
-    await tasks.addToBackend(name, {
+    await addToBackend(name, {
       type: "plugin"
     });
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/plugins/${id}`, options.owner);
+      await addCodeownersEntry(`/plugins/${id}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -294,7 +533,7 @@ const backendModule = createFactory({
   name: "backend-module",
   description: "A new backend module that extends an existing backend plugin with additional features",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [pluginIdPrompt(), moduleIdIdPrompt(), ownerPrompt()],
   async create(options, ctx) {
@@ -305,8 +544,8 @@ const backendModule = createFactory({
       scope: ctx.scope,
       plugin: true
     });
-    tasks.Task.log();
-    tasks.Task.log(`Creating backend module ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating backend module ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", dirName) : index.paths.resolveTargetRoot(`backstage-plugin-${dirName}`);
     const moduleCamelCase = camelCase__default.default(moduleId);
     const modulePascalCase = moduleCamelCase[0].toUpperCase() + moduleCamelCase.slice(1);
@@ -326,8 +565,8 @@ const backendModule = createFactory({
       }
     });
     if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/backend"))) {
-      await tasks.Task.forItem("backend", "adding dependency", async () => {
-        await tasks.addPackageDependency(
+      await Task.forItem("backend", "adding dependency", async () => {
+        await addPackageDependency(
           index.paths.resolveTargetRoot("packages/backend/package.json"),
           {
             dependencies: {
@@ -337,14 +576,14 @@ const backendModule = createFactory({
         );
       });
     }
-    await tasks.addToBackend(name, {
+    await addToBackend(name, {
       type: "module"
     });
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/plugins/${dirName}`, options.owner);
+      await addCodeownersEntry(`/plugins/${dirName}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -355,7 +594,7 @@ const nodeLibraryPackage = createFactory({
   name: "node-library",
   description: "A new node-library package, exporting shared functionality for backend plugins and modules",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
   async create(options, ctx) {
@@ -365,8 +604,8 @@ const nodeLibraryPackage = createFactory({
       scope: ctx.scope,
       plugin: false
     });
-    tasks.Task.log();
-    tasks.Task.log(`Creating node-library package ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating node-library package ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("packages", id) : index.paths.resolveTargetRoot(`${id}`);
     await executePluginPackageTemplate(ctx, {
       targetDir,
@@ -381,10 +620,10 @@ const nodeLibraryPackage = createFactory({
       }
     });
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/packages/${id}`, options.owner);
+      await addCodeownersEntry(`/packages/${id}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -395,7 +634,7 @@ const webLibraryPackage = createFactory({
   name: "web-library",
   description: "A new web-library package, exporting shared functionality for frontend plugins",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
   async create(options, ctx) {
@@ -405,8 +644,8 @@ const webLibraryPackage = createFactory({
       scope: ctx.scope,
       plugin: false
     });
-    tasks.Task.log();
-    tasks.Task.log(`Creating web-library package ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating web-library package ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("packages", id) : index.paths.resolveTargetRoot(`${id}`);
     await executePluginPackageTemplate(ctx, {
       targetDir,
@@ -421,10 +660,10 @@ const webLibraryPackage = createFactory({
       }
     });
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/packages/${id}`, options.owner);
+      await addCodeownersEntry(`/packages/${id}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -435,7 +674,7 @@ const pluginCommon = createFactory({
   name: "plugin-common",
   description: "A new isomorphic common plugin package",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
   async create(options, ctx) {
@@ -446,8 +685,8 @@ const pluginCommon = createFactory({
       scope: ctx.scope,
       plugin: true
     });
-    tasks.Task.log();
-    tasks.Task.log(`Creating common plugin package ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating common plugin package ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", suffix) : index.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
     await executePluginPackageTemplate(ctx, {
       targetDir,
@@ -462,10 +701,10 @@ const pluginCommon = createFactory({
       }
     });
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/plugins/${suffix}`, options.owner);
+      await addCodeownersEntry(`/plugins/${suffix}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -476,7 +715,7 @@ const pluginNode = createFactory({
   name: "plugin-node",
   description: "A new Node.js library plugin package",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
   async create(options, ctx) {
@@ -487,8 +726,8 @@ const pluginNode = createFactory({
       scope: ctx.scope,
       plugin: true
     });
-    tasks.Task.log();
-    tasks.Task.log(`Creating Node.js plugin library ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating Node.js plugin library ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", suffix) : index.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
     await executePluginPackageTemplate(ctx, {
       targetDir,
@@ -503,10 +742,10 @@ const pluginNode = createFactory({
       }
     });
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/plugins/${suffix}`, options.owner);
+      await addCodeownersEntry(`/plugins/${suffix}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -517,7 +756,7 @@ const pluginWeb = createFactory({
   name: "plugin-react",
   description: "A new web library plugin package",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
   async create(options, ctx) {
@@ -528,8 +767,8 @@ const pluginWeb = createFactory({
       scope: ctx.scope,
       plugin: true
     });
-    tasks.Task.log();
-    tasks.Task.log(`Creating web plugin library ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating web plugin library ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", suffix) : index.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
     await executePluginPackageTemplate(ctx, {
       targetDir,
@@ -544,10 +783,10 @@ const pluginWeb = createFactory({
       }
     });
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/plugins/${suffix}`, options.owner);
+      await addCodeownersEntry(`/plugins/${suffix}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -558,7 +797,7 @@ const scaffolderModule = createFactory({
   name: "scaffolder-module",
   description: "An module exporting custom actions for @backstage/plugin-scaffolder-backend",
   optionsDiscovery: async () => ({
-    codeOwnersPath: await codeowners.getCodeownersFilePath(index.paths.targetRoot)
+    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
   }),
   optionsPrompts: [
     {
@@ -584,8 +823,8 @@ const scaffolderModule = createFactory({
       scope: ctx.scope,
       plugin: true
     });
-    tasks.Task.log();
-    tasks.Task.log(`Creating module ${chalk__default.default.cyan(name)}`);
+    Task.log();
+    Task.log(`Creating module ${chalk__default.default.cyan(name)}`);
     const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", slug) : index.paths.resolveTargetRoot(`backstage-plugin-${slug}`);
     await executePluginPackageTemplate(ctx, {
       targetDir,
@@ -600,8 +839,8 @@ const scaffolderModule = createFactory({
       }
     });
     if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/backend"))) {
-      await tasks.Task.forItem("backend", "adding dependency", async () => {
-        await tasks.addPackageDependency(
+      await Task.forItem("backend", "adding dependency", async () => {
+        await addPackageDependency(
           index.paths.resolveTargetRoot("packages/backend/package.json"),
           {
             dependencies: {
@@ -611,14 +850,14 @@ const scaffolderModule = createFactory({
         );
       });
     }
-    await tasks.addToBackend(name, {
+    await addToBackend(name, {
       type: "module"
     });
     if (options.owner) {
-      await codeowners.addCodeownersEntry(`/plugins/${slug}`, options.owner);
+      await addCodeownersEntry(`/plugins/${slug}`, options.owner);
     }
-    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await tasks.Task.forCommand("yarn lint --fix", {
+    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await Task.forCommand("yarn lint --fix", {
       cwd: targetDir,
       optional: true
     });
@@ -770,22 +1009,22 @@ var _new = async (opts) => {
         modified = true;
       }
     });
-    tasks.Task.log();
-    tasks.Task.log(`\u{1F389}  Successfully created ${factory.name}`);
-    tasks.Task.log();
+    Task.log();
+    Task.log(`\u{1F389}  Successfully created ${factory.name}`);
+    Task.log();
   } catch (error) {
     errors.assertError(error);
-    tasks.Task.error(error.message);
+    Task.error(error.message);
     if (modified) {
-      tasks.Task.log("It seems that something went wrong in the creation process \u{1F914}");
-      tasks.Task.log();
-      tasks.Task.log(
+      Task.log("It seems that something went wrong in the creation process \u{1F914}");
+      Task.log();
+      Task.log(
         "We have left the changes that were made intact in case you want to"
       );
-      tasks.Task.log(
+      Task.log(
         "continue manually, but you can also revert the changes and try again."
       );
-      tasks.Task.error(`\u{1F525}  Failed to create ${factory.name}!`);
+      Task.error(`\u{1F525}  Failed to create ${factory.name}!`);
     }
   } finally {
     for (const dir of tempDirs) {
@@ -801,4 +1040,4 @@ var _new = async (opts) => {
 };
 
 exports.default = _new;
-//# sourceMappingURL=new-DJUBFwiF.cjs.js.map
+//# sourceMappingURL=new-C0D_k25O.cjs.js.map