@pagopa/dx-cli 0.6.0 → 0.8.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,359 @@ 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);
+          map.set("permissions", {
+            attestations: "write",
+            contents: "read",
+            "id-token": "write"
+          });
+          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";
+var NPM = class {
+  lockFileName = "package-lock.json";
+  async listWorkspaces() {
+    const { stdout } = await $`npm query .workspace`;
+    const workspaces = JSON.parse(stdout);
+    const workspaceNames = [];
+    if (Array.isArray(workspaces)) {
+      for (const ws of workspaces) {
+        if (Object.hasOwn(ws, "name")) {
+          workspaceNames.push(ws.name);
+        }
+      }
+    }
+    return workspaceNames;
+  }
+};
+var Yarn = class {
+  lockFileName = "yarn.lock";
+  async listWorkspaces() {
+    const { stdout } = await $({ lines: true })`yarn workspaces list --json`;
+    const workspaceNames = [];
+    for (const line of stdout) {
+      const ws = JSON.parse(line);
+      if (Object.hasOwn(ws, "name")) {
+        workspaceNames.push(ws.name);
+      }
+    }
+    return workspaceNames;
+  }
+};
+async function extractPackageExtensions() {
+  try {
+    const yarnrc = await fs.readFile(".yarnrc.yml", "utf-8");
+    const parsed = YAML2.parse(yarnrc);
+    if (parsed.packageExtensions) {
+      return parsed.packageExtensions;
+    }
+  } catch {
+  }
+  return void 0;
+}
+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 replacePMOccurrences() {
+  const logger2 = getLogger4(["dx-cli", "codemod"]);
+  logger2.info("Replacing yarn and npm occurrences in files...");
+  const results = await replaceInFile3({
+    allowEmptyPaths: true,
+    files: ["**/*.json", "**/*.md", "**/Dockerfile", "**/docker-compose.yml"],
+    from: [
+      "https://yarnpkg.com/",
+      "https://classic.yarnpkg.com/",
+      /\b(yarn workspace|npm -(\b-workspace\b|\bw\b)) (\S+)\b/g,
+      /\b(yarn workspace|npm -(\b-workspace\b|\bw\b)) /g,
+      /\b(yarn install --immutable|npm ci)\b/g,
+      /\b(yarn -q dlx|npx)\b/g,
+      /\b(Yarn|npm)\b/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, packageExtensions) {
+  const pnpmWorkspace = {
+    packageExtensions,
+    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 pm = info.packageManager === "yarn" ? new Yarn() : new NPM();
+  const logger2 = getLogger4(["dx-cli", "codemod"]);
+  const localWorkspaces = await pm.listWorkspaces();
+  logger2.info("Using the {protocol} protocol for local dependencies", {
+    protocol: "workspace:"
+  });
+  if (localWorkspaces.length > 0) {
+    await replaceInFile3({
+      allowEmptyPaths: true,
+      files: ["**/package.json"],
+      from: localWorkspaces.map((ws) => new RegExp(`"${ws}": ".*?"`, "g")),
+      to: localWorkspaces.map((ws) => `"${ws}": "workspace:^"`)
+    });
+  }
+  logger2.info("Remove unused fields from {file}", {
+    file: "package.json"
+  });
+  const workspaces = await preparePackageJsonForPnpm();
+  const packageExtensions = info.packageManager === "yarn" ? await extractPackageExtensions() : void 0;
+  logger2.info("Create {file}", {
+    file: "pnpm-workspace.yaml"
+  });
+  await writePnpmWorkspaceFile(workspaces, packageExtensions);
+  await $`corepack pnpm@latest add --config pnpm-plugin-pagopa`;
+  logger2.info("Remove node_modules and yarn files");
+  await removeFiles(
+    ".yarnrc",
+    ".yarnrc.yml",
+    "yarn.config.cjs",
+    ".yarn",
+    ".pnp.cjs",
+    ".pnp.loader.cjs",
+    "node_modules"
+  );
+  const stat2 = await fs.stat(pm.lockFileName);
+  if (stat2.isFile()) {
+    logger2.info("Importing {source} to {target}", {
+      source: pm.lockFileName,
+      target: "pnpm-lock.yaml"
+    });
+    await $`corepack pnpm@latest import ${pm.lockFileName}`;
+    await removeFiles(pm.lockFileName);
+  } else {
+    logger2.info("No {source} file found, skipping import.", {
+      source: pm.lockFileName
+    });
+  }
+  await replacePMOccurrences();
+  await updateDXWorkflows();
+  logger2.info("Setting pnpm as the package manager...");
+  await $`corepack use pnpm@latest`;
+};
+var use_pnpm_default = {
+  apply,
+  description: "Migrate the project to use pnpm as the package manager",
+  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 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 +375,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 +463,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 +478,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 +499,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 +638,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 +664,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,13 +677,13 @@ 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);
 });
 
@@ -402,23 +725,21 @@ var makeInitCommand = () => new Command4().name("init").description(
 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.6.0"}`);
+  const logger2 = getLogger7(["dx-cli", "version"]);
+  logger2.info(`dx CLI version: ${"0.8.0"}`);
 }
 
 // src/adapters/commander/commands/version.ts
 var makeVersionCommand = () => new Command5().name("version").alias("v").action(() => printVersion());
 
 // src/adapters/commander/index.ts
-var makeCli = (deps2, config2) => {
+var makeCli = (deps2, config2, cliDeps) => {
   const program2 = new Command6();
-  program2.name("dx").description("The CLI for DX-Platform").version("0.6.0");
+  program2.name("dx").description("The CLI for DX-Platform").version("0.8.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());
   }
@@ -428,9 +749,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) {
@@ -448,7 +769,7 @@ import * as process3 from "process";
 
 // src/adapters/node/fs/file-reader.ts
 import { ResultAsync as ResultAsync6 } from "neverthrow";
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 
 // src/adapters/zod/index.ts
 import { ResultAsync as ResultAsync5 } from "neverthrow";
@@ -465,13 +786,13 @@ var parseJson = Result2.fromThrowable(
 );
 
 // src/adapters/node/fs/file-reader.ts
-var readFile = (filePath) => ResultAsync6.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 readFileAndDecode = (filePath, schema) => readFile2(filePath).andThen(parseJson).andThen(decode(schema));
 var fileExists = (path2) => ResultAsync6.fromPromise(
-  fs2.stat(path2),
+  fs3.stat(path2),
   () => new Error(`${path2} not found.`)
 ).map(() => true);
 
@@ -501,7 +822,7 @@ var makePackageJsonReader = () => ({
 
 // src/adapters/node/repository.ts
 import * as glob from "glob";
-import { okAsync as okAsync3, ResultAsync as ResultAsync7 } from "neverthrow";
+import { okAsync as okAsync2, ResultAsync as ResultAsync7 } from "neverthrow";
 import * as path from "path";
 import { z as z3 } from "zod/v4";
 
@@ -535,11 +856,11 @@ var resolveWorkspacePattern = (repoRoot2, pattern) => ResultAsync7.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(
@@ -567,7 +888,7 @@ var makeRepositoryReader = () => ({
   fileExists,
   findRepositoryRoot,
   getWorkspaces,
-  readFile
+  readFile: readFile2
 });
 
 // src/config.ts
@@ -581,10 +902,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();
@@ -607,7 +941,7 @@ await configure({
     }
   }
 });
-var logger = getLogger4(["dx-cli"]);
+var logger = getLogger9(["dx-cli"]);
 var repositoryReader = makeRepositoryReader();
 var packageJsonReader = makePackageJsonReader();
 var validationReporter = makeValidationReporter();
@@ -626,13 +960,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.6.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "A CLI useful to manage DX tools.",
   "repository": {
@@ -22,13 +22,16 @@
     "@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",
-    "@pagopa/monorepo-generator": "^0.6.0"
+    "@pagopa/monorepo-generator": "^0.8.0"
   },
   "devDependencies": {
     "@tsconfig/node22": "22.0.2",