@pagopa/dx-cli 0.5.0 → 0.7.0

package/bin/index.js

@@ -2,22 +2,10 @@
 
 // src/index.ts
 import "core-js/actual/set/index.js";
-import { configure, getConsoleSink, getLogger as getLogger4 } from "@logtape/logtape";
-
-// src/adapters/codemods/example.ts
-import { okAsync } from "neverthrow";
-var apply = () => {
-  console.log("Hello from example codemod!");
-  return okAsync(void 0);
-};
-var example_default = {
-  apply,
-  description: "An example codemod that does nothing",
-  id: "example"
-};
+import { configure, getConsoleSink, getLogger as getLogger9 } from "@logtape/logtape";
 
 // src/adapters/codemods/registry.ts
-import { okAsync as okAsync2 } from "neverthrow";
+import { okAsync } from "neverthrow";
 var LocalCodemodRegistry = class {
   #m;
   constructor() {
@@ -27,22 +15,296 @@ var LocalCodemodRegistry = class {
     this.#m.set(codemod.id, codemod);
   }
   getAll() {
-    return okAsync2(Array.from(this.#m.values()));
+    return okAsync(Array.from(this.#m.values()));
   }
   getById(id) {
-    return okAsync2(this.#m.get(id));
+    return okAsync(this.#m.get(id));
+  }
+};
+
+// src/adapters/codemods/update-code-review.ts
+import { getLogger as getLogger2 } from "@logtape/logtape";
+import { replaceInFile } from "replace-in-file";
+
+// src/adapters/codemods/git.ts
+import { getLogger } from "@logtape/logtape";
+import { Octokit } from "octokit";
+var getLatestCommitSha = async (owner, repo, ref = "main") => {
+  const octokit = new Octokit();
+  const response = await octokit.rest.repos.getCommit({
+    owner,
+    ref,
+    repo
+  });
+  return response.data.sha;
+};
+var getLatestCommitShaOrRef = async (owner, repo, ref = "main") => {
+  const logger2 = getLogger(["dx-cli", "codemod"]);
+  return getLatestCommitSha(owner, repo, ref).catch(() => {
+    logger2.warn(
+      "Failed to fetch the latest commit from {owner}/{repo}, fallback to {fallback}",
+      { fallback: ref, owner, repo }
+    );
+    return ref;
+  });
+};
+
+// src/adapters/codemods/update-code-review.ts
+var updateJSCodeReview = async (sha) => {
+  const logger2 = getLogger2(["dx-cli", "codemod"]);
+  const results = await replaceInFile({
+    allowEmptyPaths: true,
+    files: [".github/workflows/*.yaml"],
+    from: [/pagopa\/dx\/.github\/workflows\/js_code_review.yaml@(\S+)/g],
+    to: [`pagopa/dx/.github/workflows/js_code_review.yaml@${sha}`]
+  });
+  const updated = results.filter((r) => r.hasChanged).map((r) => r.file);
+  updated.forEach((filename) => {
+    logger2.info("Workflow {filename} updated", { filename });
+  });
+  return updated;
+};
+var updateCodeReview = {
+  apply: async () => {
+    const logger2 = getLogger2(["dx-cli", "codemod"]);
+    const owner = "pagopa";
+    const repo = "dx";
+    return getLatestCommitSha(owner, repo).then(async (sha) => {
+      await updateJSCodeReview(sha);
+    }).catch(() => {
+      logger2.error(
+        "Failed to fetch the latest commit sha from {owner}/{repo}",
+        {
+          owner,
+          repo
+        }
+      );
+    });
+  },
+  description: "Update js_code_review workflow to its latest version",
+  id: "update-code-review"
+};
+
+// src/adapters/codemods/use-azure-appsvc.ts
+import { getLogger as getLogger3 } from "@logtape/logtape";
+import { replaceInFile as replaceInFile2 } from "replace-in-file";
+import YAML from "yaml";
+var isChildOf = (path2, key) => {
+  const ancestor = path2.at(-1);
+  return YAML.isPair(ancestor) && YAML.isScalar(ancestor.key) && typeof ancestor.key.value === "string" && ancestor.key.value === key;
+};
+var migrateWorkflow = (sha) => (workflow, filename) => {
+  const logger2 = getLogger3(["dx-cli", "codemod"]);
+  logger2.debug("Processing {filename} file", { filename });
+  const document = YAML.parseDocument(workflow);
+  let updated = false;
+  YAML.visit(document, {
+    Map(_, map, path2) {
+      if (isChildOf(path2, "jobs") || isChildOf(path2, "with")) {
+        return void 0;
+      }
+      if (map.has("jobs")) {
+        return void 0;
+      }
+      if (map.has("uses")) {
+        const uses = map.get("uses");
+        if (typeof uses === "string" && uses.match(
+          /^pagopa\/dx\/.github\/workflows\/(web|function)_app_deploy/
+        )) {
+          logger2.debug("Adding disable_auto_staging_deploy");
+          map.addIn(["with", "disable_auto_staging_deploy"], true);
+          updated = true;
+          return void 0;
+        }
+      }
+      return YAML.visit.SKIP;
+    },
+    Pair(_, pair) {
+      if (YAML.isScalar(pair.key)) {
+        if (pair.key.value === "function_app_name") {
+          updated = true;
+          logger2.debug("Updating function_app_name to web_app_name");
+          return new YAML.Pair("web_app_name", pair.value);
+        }
+        if (pair.key.value === "use_staging_slot") {
+          updated = true;
+          logger2.debug("Removing use_staging_slot");
+          return YAML.visit.REMOVE;
+        }
+        if (pair.key.value === "uses") {
+          updated = true;
+          logger2.debug("Updating uses value");
+          return new YAML.Pair(
+            "uses",
+            `pagopa/dx/.github/workflows/release-azure-appsvc.yaml@${sha}`
+          );
+        }
+      }
+    }
+  });
+  if (updated) {
+    logger2.info("Workflow {filename} updated", {
+      filename
+    });
+    return YAML.stringify(document);
   }
+  logger2.debug("No changes applied to {filename}", { filename });
+  return workflow;
+};
+var useAzureAppsvc = {
+  apply: async () => {
+    const sha = await getLatestCommitShaOrRef("pagopa", "dx");
+    await replaceInFile2({
+      allowEmptyPaths: true,
+      files: [".github/workflows/*.yaml"],
+      processor: migrateWorkflow(sha)
+    });
+  },
+  description: "Refactor legacy deploy workflows to use release-azure-appsvc",
+  id: "use-azure-appsvc"
+};
+
+// src/adapters/codemods/use-pnpm.ts
+import { getLogger as getLogger4 } from "@logtape/logtape";
+import { $ } from "execa";
+import * as fs from "fs/promises";
+import { replaceInFile as replaceInFile3 } from "replace-in-file";
+import YAML2 from "yaml";
+async function preparePackageJsonForPnpm() {
+  const packageJson2 = await fs.readFile("package.json", "utf-8");
+  const manifest = JSON.parse(packageJson2);
+  let workspaces = [];
+  if (Object.hasOwn(manifest, "packageManager")) {
+    delete manifest.packageManager;
+  }
+  if (Object.hasOwn(manifest, "workspaces")) {
+    if (Array.isArray(manifest.workspaces)) {
+      workspaces = manifest.workspaces;
+    }
+    delete manifest.workspaces;
+  }
+  await fs.writeFile("package.json", JSON.stringify(manifest, null, 2));
+  return workspaces;
+}
+async function removeFiles(...files) {
+  await Promise.all(
+    files.map(
+      (file) => (
+        // Remove the file if it exists, fail silently if it doesn't.
+        fs.rm(file, { force: true, recursive: true }).catch(() => void 0)
+      )
+    )
+  );
+}
+async function replaceYarnOccurrences() {
+  const logger2 = getLogger4(["dx-cli", "codemod"]);
+  logger2.info("Replacing yarn occurrences in files...");
+  const results = await replaceInFile3({
+    allowEmptyPaths: true,
+    files: ["**/*.json", "**/*.md", "**/Dockerfile", "**/docker-compose.yml"],
+    from: [
+      "https://yarnpkg.com/",
+      "https://classic.yarnpkg.com/",
+      /yarn workspace (\S+)/g,
+      /yarn workspace/g,
+      /yarn install --immutable/g,
+      /yarn -q dlx/g,
+      /Yarn/gi
+    ],
+    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+    to: [
+      "https://pnpm.io/",
+      "https://pnpm.io/",
+      "pnpm --filter $1",
+      "pnpm --filter <package-selector>",
+      "pnpm install --frozen-lockfile",
+      "pnpm dlx",
+      "pnpm"
+    ]
+  });
+  const count = results.reduce(
+    (acc, file) => file.hasChanged ? acc + 1 : acc,
+    0
+  );
+  logger2.info("Replaced yarn occurrences in {count} files", { count });
+}
+async function updateDXWorkflows() {
+  const logger2 = getLogger4(["dx-cli", "codemod"]);
+  logger2.info("Updating Github Workflows workflows...");
+  const sha = await getLatestCommitShaOrRef("pagopa", "dx");
+  const ignore = await updateJSCodeReview(sha);
+  await replaceInFile3({
+    allowEmptyPaths: true,
+    files: [".github/workflows/*.yaml"],
+    ignore,
+    processor: migrateWorkflow(sha)
+  });
+}
+async function writePnpmWorkspaceFile(workspaces) {
+  const pnpmWorkspace = {
+    packages: workspaces.length > 0 ? workspaces : ["apps/*", "packages/*"]
+  };
+  const yamlContent = YAML2.stringify(pnpmWorkspace);
+  await fs.writeFile("pnpm-workspace.yaml", yamlContent, "utf-8");
+}
+var apply = async (info) => {
+  if (info.packageManager === "pnpm") {
+    throw new Error("Project is already using pnpm");
+  }
+  const logger2 = getLogger4(["dx-cli", "codemod"]);
+  logger2.info("Remove unused fields from {file}", {
+    file: "package.json"
+  });
+  const workspaces = await preparePackageJsonForPnpm();
+  logger2.info("Create {file}", {
+    file: "pnpm-workspace.yaml"
+  });
+  await writePnpmWorkspaceFile(workspaces);
+  logger2.info("Remove node_modules and yarn files");
+  await removeFiles(
+    ".yarnrc",
+    ".yarnrc.yml",
+    "yarn.config.cjs",
+    ".yarn",
+    ".pnp.cjs",
+    ".pnp.loader.cjs",
+    "node_modules"
+  );
+  logger2.info("Importing {source} to {target}", {
+    source: "yarn.lock",
+    target: "pnpm-lock.yaml"
+  });
+  try {
+    await fs.access("yarn.lock");
+    await $`corepack pnpm@latest import yarn.lock`;
+    await removeFiles("yarn.lock");
+  } catch {
+    logger2.info("No yarn.lock file found, skipping import.");
+  }
+  await $`corepack pnpm@latest add --config pnpm-plugin-pagopa`;
+  await replaceYarnOccurrences();
+  await updateDXWorkflows();
+  logger2.info("Setting pnpm as the package manager...");
+  await $`corepack use pnpm@latest`;
+};
+var use_pnpm_default = {
+  apply,
+  description: "A codemod that switches the project to use pnpm",
+  id: "use-pnpm"
 };
 
 // src/adapters/codemods/index.ts
 var registry = new LocalCodemodRegistry();
-registry.add(example_default);
+registry.add(use_pnpm_default);
+registry.add(useAzureAppsvc);
+registry.add(updateCodeReview);
 var codemods_default = registry;
 
 // src/adapters/commander/index.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/adapters/commander/commands/codemod.ts
+import { getLogger as getLogger5 } from "@logtape/logtape";
 import { Command } from "commander";
 var makeCodemodCommand = ({
   applyCodemodById: applyCodemodById2,
@@ -50,16 +312,14 @@ var makeCodemodCommand = ({
 }) => new Command("codemod").description("Manage and apply migration scripts to the repository").addCommand(
   new Command("list").description("List available migration scripts").action(async function() {
     await listCodemods2().andTee(
-      (codemods) => (
-        // eslint-disable-next-line no-console
-        console.table(codemods, ["id", "description"])
-      )
+      (codemods) => console.table(codemods, ["id", "description"])
     ).orTee((error) => this.error(error.message));
   })
 ).addCommand(
   new Command("apply").argument("<id>", "The id of the codemod to apply").description("Apply migration scripts to the repository").action(async function(id) {
+    const logger2 = getLogger5(["dx-cli", "codemod"]);
     await applyCodemodById2(id).andTee(() => {
-      console.log("Codemod applied successfully \u2705");
+      logger2.info("Codemod applied \u2705");
     }).orTee((error) => this.error(error.message));
   })
 );
@@ -140,7 +400,7 @@ var checkMonorepoScripts = async (dependencies, config2) => {
 
 // src/domain/repository.ts
 import { ok as ok2 } from "neverthrow";
-import fs from "path";
+import fs2 from "path";
 import coerce from "semver/functions/coerce.js";
 import semverGte from "semver/functions/gte.js";
 var isVersionValid = (version, minVersion) => {
@@ -155,7 +415,7 @@ var checkPreCommitConfig = async (dependencies, config2) => {
   const { repositoryReader: repositoryReader2 } = dependencies;
   const checkName = "Pre-commit Configuration";
   const preCommitResult = await repositoryReader2.fileExists(
-    fs.join(config2.repository.root, ".pre-commit-config.yaml")
+    fs2.join(config2.repository.root, ".pre-commit-config.yaml")
   );
   if (preCommitResult.isOk() && preCommitResult.value) {
     return ok2({
@@ -176,7 +436,7 @@ var checkTurboConfig = async (dependencies, config2) => {
   const checkName = "Turbo Configuration";
   const repoRoot2 = config2.repository.root;
   const turboResult = await repositoryReader2.fileExists(
-    fs.join(repoRoot2, "turbo.json")
+    fs2.join(repoRoot2, "turbo.json")
   );
   if (turboResult.isErr()) {
     return ok2({
@@ -315,7 +575,7 @@ var makeDoctorCommand = (dependencies, config2) => new Command2().name("doctor")
 import { Command as Command3 } from "commander";
 
 // src/domain/info.ts
-import { getLogger } from "@logtape/logtape";
+import { getLogger as getLogger6 } from "@logtape/logtape";
 import { join } from "path";
 var detectFromLockFile = async (dependencies, config2) => {
   const { repositoryReader: repositoryReader2 } = dependencies;
@@ -341,7 +601,7 @@ var detectPackageManager = async (dependencies, config2) => {
 var detectNodeVersion = async ({ repositoryReader: repositoryReader2 }, nodeVersionFilePath) => await repositoryReader2.readFile(nodeVersionFilePath).map((nodeVersion) => nodeVersion.trim()).unwrapOr(void 0);
 var detectTerraformVersion = async ({ repositoryReader: repositoryReader2 }, terraformVersionFilePath) => await repositoryReader2.readFile(terraformVersionFilePath).map((tfVersion) => tfVersion.trim()).unwrapOr(void 0);
 var detectTurboVersion = ({ devDependencies }) => devDependencies.get("turbo")?.trim();
-var getInfo = async (dependencies, config2) => ({
+var getInfo = (dependencies, config2) => async () => ({
   node: await detectNodeVersion(
     { repositoryReader: dependencies.repositoryReader },
     `${config2.repository.root}/.node-version`
@@ -354,36 +614,73 @@ var getInfo = async (dependencies, config2) => ({
   turbo: detectTurboVersion(dependencies.packageJson)
 });
 var printInfo = (result) => {
-  const logger2 = getLogger("json");
+  const logger2 = getLogger6("json");
   logger2.info(JSON.stringify(result));
 };
 
 // src/adapters/commander/commands/info.ts
 var makeInfoCommand = (dependencies, config2) => new Command3().name("info").description("Display information about the project").action(async () => {
-  const result = await getInfo(dependencies, config2);
+  const result = await getInfo(dependencies, config2)();
   printInfo(result);
 });
 
-// src/adapters/commander/commands/version.ts
+// src/adapters/commander/commands/init.ts
+import scaffoldMonorepo from "@pagopa/monorepo-generator";
 import { Command as Command4 } from "commander";
+import { Result, ResultAsync as ResultAsync4 } from "neverthrow";
+import nodePlop from "node-plop";
+var initPlop = () => ResultAsync4.fromPromise(
+  nodePlop(),
+  () => new Error("Failed to initialize plop")
+);
+var getGenerator = (plopAPI) => Result.fromThrowable(
+  plopAPI.getGenerator,
+  () => new Error("Generator not found")
+);
+var runGenerator = (generator) => ResultAsync4.fromPromise(
+  generator.runPrompts(),
+  () => new Error("Failed to run the generator prompts")
+).andThen(
+  (answers) => ResultAsync4.fromPromise(
+    generator.runActions(answers),
+    () => new Error("Failed to run the generator actions")
+  )
+);
+var makeInitCommand = () => new Command4().name("init").description(
+  "Command to initialize resources (like projects, subscriptions, ...)"
+).addCommand(
+  new Command4("project").description("Initialize a new monorepo project").action(async function() {
+    await initPlop().andTee(scaffoldMonorepo).andThen((plop) => getGenerator(plop)("monorepo")).andThen(runGenerator).andTee(() => {
+      console.log("Monorepo initialized successfully \u2705");
+    }).orTee((err2) => {
+      this.error(err2.message);
+    });
+  })
+);
+
+// src/adapters/commander/commands/version.ts
+import { Command as Command5 } from "commander";
 
 // src/domain/version.ts
-import { getLogger as getLogger2 } from "@logtape/logtape";
+import { getLogger as getLogger7 } from "@logtape/logtape";
 function printVersion() {
-  const logger2 = getLogger2(["dx-cli", "version"]);
-  logger2.info(`dx CLI version: ${"0.5.0"}`);
+  const logger2 = getLogger7(["dx-cli", "version"]);
+  logger2.info(`dx CLI version: ${"0.7.0"}`);
 }
 
 // src/adapters/commander/commands/version.ts
-var makeVersionCommand = () => new Command4().name("version").alias("v").action(() => printVersion());
+var makeVersionCommand = () => new Command5().name("version").alias("v").action(() => printVersion());
 
 // src/adapters/commander/index.ts
-var makeCli = (deps2, config2) => {
-  const program2 = new Command5();
-  program2.name("dx").description("The CLI for DX-Platform").version("0.5.0");
+var makeCli = (deps2, config2, cliDeps) => {
+  const program2 = new Command6();
+  program2.name("dx").description("The CLI for DX-Platform").version("0.7.0");
   program2.addCommand(makeDoctorCommand(deps2, config2));
   if (process.env.ENABLE_CODEMODS) {
-    program2.addCommand(makeCodemodCommand(deps2));
+    program2.addCommand(makeCodemodCommand(cliDeps));
+  }
+  if (process.env.ENABLE_INIT_COMMAND) {
+    program2.addCommand(makeInitCommand());
   }
   program2.addCommand(makeVersionCommand());
   program2.addCommand(makeInfoCommand(deps2, config2));
@@ -391,9 +688,9 @@ var makeCli = (deps2, config2) => {
 };
 
 // src/adapters/logtape/validation-reporter.ts
-import { getLogger as getLogger3 } from "@logtape/logtape";
+import { getLogger as getLogger8 } from "@logtape/logtape";
 var makeValidationReporter = () => {
-  const logger2 = getLogger3(["dx-cli", "validation"]);
+  const logger2 = getLogger8(["dx-cli", "validation"]);
   return {
     reportCheckResult(result) {
       if (result.isValid) {
@@ -410,31 +707,31 @@ import { join as join2 } from "path";
 import * as process3 from "process";
 
 // src/adapters/node/fs/file-reader.ts
-import { ResultAsync as ResultAsync5 } from "neverthrow";
-import fs2 from "fs/promises";
+import { ResultAsync as ResultAsync6 } from "neverthrow";
+import fs3 from "fs/promises";
 
 // src/adapters/zod/index.ts
-import { ResultAsync as ResultAsync4 } from "neverthrow";
-var decode = (schema) => ResultAsync4.fromThrowable(
+import { ResultAsync as ResultAsync5 } from "neverthrow";
+var decode = (schema) => ResultAsync5.fromThrowable(
   schema.parseAsync,
   (cause) => new Error("File content is not valid for the given schema", { cause })
 );
 
 // src/adapters/node/json/index.ts
-import { Result } from "neverthrow";
-var parseJson = Result.fromThrowable(
+import { Result as Result2 } from "neverthrow";
+var parseJson = Result2.fromThrowable(
   JSON.parse,
   (cause) => new Error("Failed to parse JSON", { cause })
 );
 
 // src/adapters/node/fs/file-reader.ts
-var readFile = (filePath) => ResultAsync5.fromPromise(
-  fs2.readFile(filePath, "utf-8"),
+var readFile2 = (filePath) => ResultAsync6.fromPromise(
+  fs3.readFile(filePath, "utf-8"),
   (cause) => new Error(`Failed to read file: ${filePath}`, { cause })
 );
-var readFileAndDecode = (filePath, schema) => readFile(filePath).andThen(parseJson).andThen(decode(schema));
-var fileExists = (path2) => ResultAsync5.fromPromise(
-  fs2.stat(path2),
+var readFileAndDecode = (filePath, schema) => readFile2(filePath).andThen(parseJson).andThen(decode(schema));
+var fileExists = (path2) => ResultAsync6.fromPromise(
+  fs3.stat(path2),
   () => new Error(`${path2} not found.`)
 ).map(() => true);
 
@@ -464,14 +761,14 @@ var makePackageJsonReader = () => ({
 
 // src/adapters/node/repository.ts
 import * as glob from "glob";
-import { okAsync as okAsync3, ResultAsync as ResultAsync6 } from "neverthrow";
+import { okAsync as okAsync2, ResultAsync as ResultAsync7 } from "neverthrow";
 import * as path from "path";
 import { z as z3 } from "zod/v4";
 
 // src/adapters/yaml/index.ts
-import { Result as Result2 } from "neverthrow";
+import { Result as Result3 } from "neverthrow";
 import yaml from "yaml";
-var parseYaml = Result2.fromThrowable(
+var parseYaml = Result3.fromThrowable(
   (content) => yaml.parse(content),
   () => new Error("Failed to parse YAML")
 );
@@ -485,7 +782,7 @@ var findRepositoryRoot = (dir = process.cwd()) => {
     )
   ).map(() => dir);
 };
-var resolveWorkspacePattern = (repoRoot2, pattern) => ResultAsync6.fromPromise(
+var resolveWorkspacePattern = (repoRoot2, pattern) => ResultAsync7.fromPromise(
   // For now it is not possible to use the fs.glob function (from node:fs/promises)
   // because it is not possible to run it on Node 20.x
   glob.glob(pattern, { cwd: repoRoot2 }),
@@ -498,17 +795,17 @@ var resolveWorkspacePattern = (repoRoot2, pattern) => ResultAsync6.fromPromise(
     subDirectories.map((directory) => path.join(repoRoot2, directory))
   )
 );
-var getWorkspaces = (repoRoot2) => readFile(path.join(repoRoot2, "pnpm-workspace.yaml")).andThen(parseYaml).andThen(
+var getWorkspaces = (repoRoot2) => readFile2(path.join(repoRoot2, "pnpm-workspace.yaml")).andThen(parseYaml).andThen(
   (obj) => (
     // If no packages are defined, go on with an empty array
     decode(z3.object({ packages: z3.array(z3.string()) }))(obj).orElse(
-      () => okAsync3({ packages: [] })
+      () => okAsync2({ packages: [] })
     )
   )
 ).andThen(
   ({ packages }) => (
     // For every package pattern in the pnpm-workspace.yaml file, get the list of subdirectories
-    ResultAsync6.combine(
+    ResultAsync7.combine(
       packages.map((pattern) => resolveWorkspacePattern(repoRoot2, pattern))
     ).map((workspacesList) => workspacesList.flat()).andThen((workspaceFolders) => {
       const workspaceResults = workspaceFolders.map(
@@ -522,7 +819,7 @@ var getWorkspaces = (repoRoot2) => readFile(path.join(repoRoot2, "pnpm-workspace
           )
         )
       );
-      return ResultAsync6.combine(workspaceResults);
+      return ResultAsync7.combine(workspaceResults);
     })
   )
 );
@@ -530,7 +827,7 @@ var makeRepositoryReader = () => ({
   fileExists,
   findRepositoryRoot,
   getWorkspaces,
-  readFile
+  readFile: readFile2
 });
 
 // src/config.ts
@@ -544,10 +841,23 @@ var getConfig = (repositoryRoot2) => ({
 });
 
 // src/use-cases/apply-codemod.ts
-import { errAsync, okAsync as okAsync4 } from "neverthrow";
-var applyCodemodById = (registry2) => (id) => registry2.getById(id).andThen(
-  (codemod) => codemod ? okAsync4(codemod) : errAsync(new Error(`Codemod with id ${id} not found`))
-).andThen((codemod) => codemod.apply());
+import { errAsync, okAsync as okAsync3, ResultAsync as ResultAsync8 } from "neverthrow";
+var getCodemodById = (registry2, id) => registry2.getById(id).andThen(
+  (codemod) => codemod ? okAsync3(codemod) : errAsync(new Error(`Codemod with id ${id} not found`))
+);
+var safeGetInfo = (getInfo2) => ResultAsync8.fromPromise(
+  getInfo2(),
+  (error) => new Error("Failed to get info", { cause: error })
+);
+var applyCodemodById = (registry2, getInfo2) => (id) => ResultAsync8.combine([
+  safeGetInfo(getInfo2),
+  getCodemodById(registry2, id)
+]).andThen(
+  ([info, codemod]) => ResultAsync8.fromPromise(codemod.apply(info), (error) => {
+    const message = error instanceof Error ? `: ${error.message}` : "";
+    return new Error("Failed to apply codemod" + message, { cause: error });
+  })
+);
 
 // src/use-cases/list-codemods.ts
 var listCodemods = (registry2) => () => registry2.getAll();
@@ -570,7 +880,7 @@ await configure({
     }
   }
 });
-var logger = getLogger4(["dx-cli"]);
+var logger = getLogger9(["dx-cli"]);
 var repositoryReader = makeRepositoryReader();
 var packageJsonReader = makePackageJsonReader();
 var validationReporter = makeValidationReporter();
@@ -589,13 +899,15 @@ if (repoPackageJson.isErr()) {
 }
 var packageJson = repoPackageJson.value;
 var deps = {
-  applyCodemodById: applyCodemodById(codemods_default),
-  listCodemods: listCodemods(codemods_default),
   packageJson,
   packageJsonReader,
   repositoryReader,
   validationReporter
 };
 var config = getConfig(repositoryRoot);
-var program = makeCli(deps, config);
+var useCases = {
+  applyCodemodById: applyCodemodById(codemods_default, getInfo(deps, config)),
+  listCodemods: listCodemods(codemods_default)
+};
+var program = makeCli(deps, config, useCases);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-cli",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "A CLI useful to manage DX tools.",
   "repository": {
@@ -22,16 +22,21 @@
     "@logtape/logtape": "^1.0.0",
     "commander": "^14.0.0",
     "core-js": "^3.44.0",
+    "execa": "^9.6.0",
     "glob": "^11.0.3",
     "neverthrow": "^8.2.0",
+    "node-plop": "^0.32.1",
+    "octokit": "^5.0.3",
+    "replace-in-file": "^8.3.0",
     "semver": "^7.7.2",
     "yaml": "^2.8.0",
-    "zod": "^3.25.28"
+    "zod": "^3.25.28",
+    "@pagopa/monorepo-generator": "^0.6.0"
   },
   "devDependencies": {
     "@tsconfig/node22": "22.0.2",
     "@types/node": "^22.16.2",
-    "@types/semver": "^7.7.0",
+    "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.30.0",
     "memfs": "^4.23.0",
@@ -40,7 +45,7 @@
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
     "vitest-mock-extended": "^3.1.0",
-    "@pagopa/eslint-config": "^5.0.0"
+    "@pagopa/eslint-config": "^5.1.0"
   },
   "engines": {
     "node": ">=22.0.0"