@pagopa/dx-cli 0.15.2 → 0.15.3

package/bin/index.js

@@ -1,1263 +1,9 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import "core-js/actual/set/index.js";
 import { configure, getConsoleSink } from "@logtape/logtape";
-import { Octokit as Octokit3 } from "octokit";
+import { runCli } from "../dist/index.js";
+import packageJson from "../package.json" with { type: "json" };
 
-// src/adapters/codemods/registry.ts
-import { okAsync } from "neverthrow";
-var LocalCodemodRegistry = class {
-  #m;
-  constructor() {
-    this.#m = /* @__PURE__ */ new Map();
-  }
-  add(codemod) {
-    this.#m.set(codemod.id, codemod);
-  }
-  getAll() {
-    return okAsync(Array.from(this.#m.values()));
-  }
-  getById(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";
-import * as YAML2 from "yaml";
-
-// src/adapters/codemods/git.ts
-import { getLogger } from "@logtape/logtape";
-import { Octokit } from "octokit";
-var getLatestCommitSha = async (owner, repo, ref = "main") => {
-  const octokit2 = new Octokit();
-  const response = await octokit2.rest.repos.getCommit({
-    owner,
-    ref,
-    repo
-  });
-  return response.data.sha;
-};
-var getLatestCommitShaOrRef = async (owner, repo, ref = "main") => {
-  const logger = getLogger(["dx-cli", "codemod"]);
-  return getLatestCommitSha(owner, repo, ref).catch(() => {
-    logger.warn(
-      "Failed to fetch the latest commit from {owner}/{repo}, fallback to {fallback}",
-      { fallback: ref, owner, repo }
-    );
-    return ref;
-  });
-};
-
-// src/adapters/codemods/yaml.ts
-import * as YAML from "yaml";
-var isChildOf = (path3, key) => {
-  const ancestor = path3.at(-1);
-  return YAML.isPair(ancestor) && YAML.isScalar(ancestor.key) && typeof ancestor.key.value === "string" && ancestor.key.value === key;
-};
-
-// src/adapters/codemods/update-code-review.ts
-var updateJSCodeReviewJob = (sha) => (workflow, filename) => {
-  const logger = getLogger2(["dx-cli", "codemod"]);
-  const document = YAML2.parseDocument(workflow);
-  let updated = false;
-  YAML2.visit(document, {
-    Map(_, map, path3) {
-      if (map.has("jobs") || isChildOf(path3, "jobs")) {
-        return void 0;
-      }
-      if (map.has("uses")) {
-        const uses = map.get("uses");
-        if (typeof uses === "string" && uses.startsWith("pagopa/dx/.github/workflows/js_code_review.yaml@")) {
-          map.set("secrets", "inherit");
-          map.set("permissions", {
-            contents: "read",
-            "pull-requests": "write"
-          });
-          map.set(
-            "uses",
-            `pagopa/dx/.github/workflows/js_code_review.yaml@${sha}`
-          );
-          updated = true;
-        }
-      }
-      return YAML2.visit.SKIP;
-    }
-  });
-  if (updated) {
-    logger.info("Workflow {filename} updated", {
-      filename
-    });
-    return YAML2.stringify(document);
-  }
-  return workflow;
-};
-var updateCodeReview = {
-  apply: async () => {
-    const logger = getLogger2(["dx-cli", "codemod"]);
-    const owner = "pagopa";
-    const repo = "dx";
-    return getLatestCommitSha(owner, repo).then(async (sha) => {
-      await replaceInFile({
-        allowEmptyPaths: true,
-        files: [".github/workflows/*.yaml"],
-        processor: updateJSCodeReviewJob(sha)
-      });
-    }).catch(() => {
-      logger.error(
-        "Failed to fetch the latest commit sha from {repository}",
-        {
-          repository: `${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 YAML3 from "yaml";
-var migrateWorkflow = (sha) => (workflow, filename) => {
-  const logger = getLogger3(["dx-cli", "codemod"]);
-  logger.debug("Processing {filename} file", { filename });
-  const document = YAML3.parseDocument(workflow);
-  let updated = false;
-  YAML3.visit(document, {
-    Map(_, map, path3) {
-      if (isChildOf(path3, "jobs") || isChildOf(path3, "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/
-        )) {
-          logger.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 YAML3.visit.SKIP;
-    },
-    Pair(_, pair) {
-      if (YAML3.isScalar(pair.key)) {
-        if (pair.key.value === "function_app_name") {
-          updated = true;
-          logger.debug("Updating function_app_name to web_app_name");
-          return new YAML3.Pair("web_app_name", pair.value);
-        }
-        if (pair.key.value === "use_staging_slot") {
-          updated = true;
-          logger.debug("Removing use_staging_slot");
-          return YAML3.visit.REMOVE;
-        }
-        if (pair.key.value === "uses") {
-          updated = true;
-          logger.debug("Updating uses value");
-          return new YAML3.Pair(
-            "uses",
-            `pagopa/dx/.github/workflows/release-azure-appsvc-v1.yaml@${sha}`
-          );
-        }
-      }
-    }
-  });
-  if (updated) {
-    logger.info("Workflow {filename} updated", {
-      filename
-    });
-    return YAML3.stringify(document);
-  }
-  logger.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 assert from "assert/strict";
-import fs from "fs/promises";
-import { replaceInFile as replaceInFile3 } from "replace-in-file";
-import semver from "semver";
-import YAML4 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 = YAML4.parse(yarnrc);
-    if (parsed.packageExtensions) {
-      return parsed.packageExtensions;
-    }
-  } catch {
-  }
-  return void 0;
-}
-async function preparePackageJsonForPnpm() {
-  const packageJson = await fs.readFile("package.json", "utf-8");
-  const manifest = JSON.parse(packageJson);
-  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 writePnpmWorkspaceFile(workspaces, packageExtensions) {
-  const pnpmWorkspace = {
-    cleanupUnusedCatalogs: true,
-    linkWorkspacePackages: true,
-    packageExtensions,
-    packageImportMethod: "clone-or-copy",
-    packages: workspaces.length > 0 ? workspaces : ["apps/*", "packages/*"]
-  };
-  const yamlContent = YAML4.stringify(pnpmWorkspace);
-  await fs.writeFile("pnpm-workspace.yaml", yamlContent, "utf-8");
-}
-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 logger = getLogger4(["dx-cli", "codemod"]);
-  logger.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))\b/g,
-      /\b(yarn install --immutable|npm ci)\b/g,
-      /\b(yarn -q dlx|npx)\b/g,
-      /\b((yarn|npm) run)\b/g,
-      /(^|\s|")(yarn|npm)(?!\S)/gi
-    ],
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
-    to: [
-      "https://pnpm.io/",
-      "https://pnpm.io/",
-      "pnpm --filter $3",
-      "pnpm --filter <package-selector>",
-      "pnpm install --frozen-lockfile",
-      "pnpm dlx",
-      "pnpm run",
-      "$1pnpm"
-    ]
-  });
-  const count = results.reduce(
-    (acc, file) => file.hasChanged ? acc + 1 : acc,
-    0
-  );
-  logger.info("Replaced yarn occurrences in {count} files", { count });
-}
-async function updateDXWorkflows() {
-  const logger = getLogger4(["dx-cli", "codemod"]);
-  logger.info("Updating Github Workflows workflows...");
-  const sha = await getLatestCommitShaOrRef("pagopa", "dx");
-  const results = await replaceInFile3({
-    allowEmptyPaths: true,
-    files: [".github/workflows/*.yaml"],
-    processor: updateJSCodeReviewJob(sha)
-  });
-  const ignore = results.filter((r) => r.hasChanged).map((r) => r.file);
-  await replaceInFile3({
-    allowEmptyPaths: true,
-    files: [".github/workflows/*.yaml"],
-    ignore,
-    processor: migrateWorkflow(sha)
-  });
-}
-var usePnpm = async (packageManager, currentNodeVersion) => {
-  const minNodeVersion = "20.19.5";
-  assert.notEqual(packageManager, "pnpm", "Project is already using pnpm");
-  assert.ok(
-    semver.gte(currentNodeVersion, minNodeVersion),
-    `his codemod requires Node.js >= ${minNodeVersion}. Current version: ${currentNodeVersion}`
-  );
-  const logger = getLogger4(["dx-cli", "codemod"]);
-  const pm = packageManager === "yarn" ? new Yarn() : new NPM();
-  const localWorkspaces = await pm.listWorkspaces();
-  if (localWorkspaces.length > 0) {
-    logger.info("Using the {protocol} protocol for local dependencies", {
-      protocol: "workspace:"
-    });
-    await replaceInFile3({
-      allowEmptyPaths: true,
-      files: ["**/package.json"],
-      from: localWorkspaces.map((ws) => new RegExp(`"${ws}": ".*?"`, "g")),
-      to: localWorkspaces.map((ws) => `"${ws}": "workspace:^"`)
-    });
-  }
-  logger.info("Remove unused fields from {file}", {
-    file: "package.json"
-  });
-  const workspaces = await preparePackageJsonForPnpm();
-  const packageExtensions = packageManager === "yarn" ? await extractPackageExtensions() : void 0;
-  logger.info("Create {file}", {
-    file: "pnpm-workspace.yaml"
-  });
-  await writePnpmWorkspaceFile(workspaces, packageExtensions);
-  logger.info("Remove node_modules and yarn files");
-  await removeFiles(
-    ".yarnrc",
-    ".yarnrc.yml",
-    "yarn.config.cjs",
-    ".yarn",
-    ".pnp.cjs",
-    ".pnp.loader.cjs",
-    "node_modules"
-  );
-  const stat = await fs.stat(pm.lockFileName);
-  if (stat.isFile()) {
-    logger.info("Importing {source} to {target}", {
-      source: pm.lockFileName,
-      target: "pnpm-lock.yaml"
-    });
-    await $`corepack pnpm@latest import ${pm.lockFileName}`;
-    await removeFiles(pm.lockFileName);
-  } else {
-    logger.info("No {source} file found, skipping import.", {
-      source: pm.lockFileName
-    });
-  }
-  await replacePMOccurrences();
-  await updateDXWorkflows();
-  logger.info("Adding pnpm store to .gitignore...");
-  await fs.appendFile(".gitignore", "\n\n# PNPM\n.pnpm-store");
-  logger.info("Setting pnpm as the package manager...");
-  await $`corepack use pnpm@latest`;
-};
-var apply = async (info) => {
-  const logger = getLogger4(["dx-cli", "codemod"]);
-  try {
-    await usePnpm(info.packageManager, process.versions.node);
-  } catch (error) {
-    if (error instanceof Error) {
-      logger.error(error.message);
-    }
-  }
-};
-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(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,
-  listCodemods: listCodemods2
-}) => 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) => 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 logger = getLogger5(["dx-cli", "codemod"]);
-    await applyCodemodById2(id).andTee(() => {
-      logger.info("Codemod applied \u2705");
-    }).orTee((error) => this.error(error.message));
-  })
-);
-
-// src/adapters/commander/commands/doctor.ts
-import { Command as Command2 } from "commander";
-import * as process2 from "process";
-
-// src/domain/doctor.ts
-import { ResultAsync as ResultAsync3 } from "neverthrow";
-
-// src/domain/package-json.ts
-import { err, ok } from "neverthrow";
-import { z } from "zod/v4";
-var ScriptName = z.string().brand();
-var scriptSchema = z.object({
-  name: ScriptName,
-  script: z.string()
-});
-var dependencySchema = z.object({
-  name: z.string(),
-  version: z.string()
-});
-var PackageName = z.string().min(1).brand();
-var scriptsSchema = z.record(ScriptName, z.string()).optional().transform(
-  (obj) => new Map(
-    obj ? Object.entries(obj).map(([name, script]) => [
-      ScriptName.parse(name),
-      script
-    ]) : []
-  )
-);
-var dependenciesSchema = z.record(z.string(), z.string()).optional().transform(
-  (obj) => new Map(
-    obj ? Object.entries(obj).map(([name, version]) => [name, version]) : []
-  )
-);
-var packageManagerSchema = z.enum(["npm", "pnpm", "yarn"]);
-var packageJsonSchema = z.object({
-  dependencies: dependenciesSchema,
-  devDependencies: dependenciesSchema,
-  name: PackageName,
-  packageManager: z.string().transform((str) => str.split("@")[0]).pipe(packageManagerSchema).optional(),
-  scripts: scriptsSchema
-});
-var findMissingScripts = (availableScripts, requiredScripts) => {
-  const availableScriptNames = new Set(availableScripts.keys());
-  const requiredScriptNames = new Set(requiredScripts.keys());
-  return requiredScriptNames.difference(availableScriptNames);
-};
-var checkMonorepoScripts = async (dependencies, repositoryRoot) => {
-  const { packageJsonReader: packageJsonReader2 } = dependencies;
-  const checkName = "Monorepo Scripts";
-  const scriptsResult = await packageJsonReader2.getScripts(repositoryRoot);
-  if (scriptsResult.isErr()) {
-    return err(scriptsResult.error);
-  }
-  const requiredScriptsMap = packageJsonReader2.getRootRequiredScripts();
-  const missingScripts = findMissingScripts(
-    scriptsResult.value,
-    requiredScriptsMap
-  );
-  if (missingScripts.size === 0) {
-    return ok({
-      checkName,
-      isValid: true,
-      successMessage: "Monorepo scripts are correctly set up"
-    });
-  }
-  return ok({
-    checkName,
-    errorMessage: `Missing required scripts: ${Array.from(missingScripts).join(", ")}`,
-    isValid: false
-  });
-};
-
-// src/domain/repository.ts
-import { ok as ok2 } from "neverthrow";
-import fs2 from "path";
-import coerce from "semver/functions/coerce.js";
-import semverGte from "semver/functions/gte.js";
-var isVersionValid = (version, minVersion) => {
-  const minAcceptedSemVer = coerce(minVersion);
-  const dependencySemVer = coerce(version);
-  if (!minAcceptedSemVer || !dependencySemVer) {
-    return false;
-  }
-  return semverGte(dependencySemVer, minAcceptedSemVer);
-};
-var checkPreCommitConfig = async (dependencies, repositoryRoot) => {
-  const { repositoryReader: repositoryReader2 } = dependencies;
-  const checkName = "Pre-commit Configuration";
-  const preCommitResult = await repositoryReader2.fileExists(
-    fs2.join(repositoryRoot, ".pre-commit-config.yaml")
-  );
-  if (preCommitResult.isOk() && preCommitResult.value) {
-    return ok2({
-      checkName,
-      isValid: true,
-      successMessage: "Pre-commit configuration is present in the repository root"
-    });
-  }
-  const errorMessage = preCommitResult.isErr() ? preCommitResult.error.message : `Pre-commit configuration is not present in the repository root. Please add a .pre-commit-config.yaml file to the repository root.`;
-  return ok2({
-    checkName,
-    errorMessage,
-    isValid: false
-  });
-};
-var checkTurboConfig = async (dependencies, repositoryRoot, config2) => {
-  const { packageJsonReader: packageJsonReader2, repositoryReader: repositoryReader2 } = dependencies;
-  const checkName = "Turbo Configuration";
-  const turboResult = await repositoryReader2.fileExists(
-    fs2.join(repositoryRoot, "turbo.json")
-  );
-  if (turboResult.isErr()) {
-    return ok2({
-      checkName,
-      errorMessage: turboResult.error.message,
-      isValid: false
-    });
-  }
-  const dependenciesResult = await packageJsonReader2.getDependencies(
-    repositoryRoot,
-    "dev"
-  );
-  if (dependenciesResult.isErr()) {
-    return ok2({
-      checkName,
-      errorMessage: dependenciesResult.error.message,
-      isValid: false
-    });
-  }
-  const turboVersion = dependenciesResult.value.get(
-    "turbo"
-  );
-  if (!turboVersion) {
-    return ok2({
-      checkName,
-      errorMessage: "Turbo dependency not found in devDependencies. Please add 'turbo' to your devDependencies.",
-      isValid: false
-    });
-  }
-  if (!isVersionValid(turboVersion, config2.minVersions.turbo)) {
-    return ok2({
-      checkName,
-      errorMessage: `Turbo version (${turboVersion}) is too low. Minimum required version is ${config2.minVersions.turbo}.`,
-      isValid: false
-    });
-  }
-  return ok2({
-    checkName,
-    isValid: true,
-    successMessage: "Turbo configuration is present in the monorepo root and turbo dependency is installed"
-  });
-};
-
-// src/domain/workspace.ts
-import { ok as ok3 } from "neverthrow";
-import { z as z2 } from "zod/v4";
-var WorkspaceName = z2.string().min(1).brand();
-var workspaceSchema = z2.object({
-  name: WorkspaceName,
-  path: z2.string()
-});
-var checkWorkspaces = async (dependencies, monorepoDir) => {
-  const { repositoryReader: repositoryReader2 } = dependencies;
-  const checkName = "Workspaces";
-  const workspacesResult = await repositoryReader2.getWorkspaces(monorepoDir);
-  if (workspacesResult.isErr()) {
-    return ok3({
-      checkName,
-      errorMessage: "Something is wrong with the workspaces configuration. If you need help, please contact the DevEx team.",
-      isValid: false
-    });
-  }
-  const { length: workspaceNumber } = workspacesResult.value;
-  if (workspaceNumber === 0) {
-    return ok3({
-      checkName,
-      errorMessage: "No workspace configuration found. Make sure to configure workspaces in pnpm-workspace.yaml.",
-      isValid: false
-    });
-  }
-  return ok3({
-    checkName,
-    isValid: true,
-    successMessage: `Found ${workspaceNumber} workspace${workspaceNumber === 1 ? "" : "s"}`
-  });
-};
-
-// src/domain/doctor.ts
-var runDoctor = async (dependencies, config2) => {
-  const repoRootResult = await dependencies.repositoryReader.findRepositoryRoot();
-  if (repoRootResult.isErr()) {
-    return {
-      checks: [
-        {
-          checkName: "Repository Detection",
-          errorMessage: "Could not find repository root. Make sure to run this command inside a Git repository.",
-          isValid: false
-        }
-      ],
-      hasErrors: true
-    };
-  }
-  const repositoryRoot = repoRootResult.value;
-  const doctorChecks = [
-    ResultAsync3.fromPromise(
-      checkPreCommitConfig(dependencies, repositoryRoot),
-      () => new Error("Error checking pre-commit configuration")
-    ),
-    ResultAsync3.fromPromise(
-      checkTurboConfig(dependencies, repositoryRoot, config2),
-      () => new Error("Error checking Turbo configuration")
-    ),
-    ResultAsync3.fromPromise(
-      checkMonorepoScripts(dependencies, repositoryRoot),
-      () => new Error("Error checking monorepo scripts")
-    ),
-    ResultAsync3.fromPromise(
-      checkWorkspaces(dependencies, repositoryRoot),
-      () => new Error("Error checking monorepo scripts")
-    )
-  ];
-  return ResultAsync3.combine(doctorChecks).match(
-    toDoctorResult,
-    () => ({
-      checks: [],
-      hasErrors: true
-    })
-  );
-};
-var toDoctorResult = (validationCheckResults) => {
-  const checks = validationCheckResults.map((result) => {
-    if (result.isOk()) {
-      return result.value;
-    }
-    return {
-      checkName: "Unknown",
-      errorMessage: result.error.message,
-      isValid: false
-    };
-  });
-  const hasErrors = checks.some((check) => !check.isValid);
-  return {
-    checks,
-    hasErrors
-  };
-};
-var printDoctorResult = ({ validationReporter: validationReporter2 }, result) => result.checks.map(validationReporter2.reportCheckResult);
-
-// src/adapters/commander/commands/doctor.ts
-var makeDoctorCommand = (dependencies, config2) => new Command2().name("doctor").description(
-  "Verify the repository setup according to the DevEx guidelines"
-).action(async () => {
-  const result = await runDoctor(dependencies, config2);
-  printDoctorResult(dependencies, result);
-  const exitCode = result.hasErrors ? 1 : 0;
-  process2.exit(exitCode);
-});
-
-// src/adapters/commander/commands/info.ts
-import { Command as Command3 } from "commander";
-
-// src/domain/info.ts
-import { getLogger as getLogger6 } from "@logtape/logtape";
-import { join } from "path";
-var detectFromLockFile = async (dependencies, repositoryRoot) => {
-  const { repositoryReader: repositoryReader2 } = dependencies;
-  const pnpmResult = await repositoryReader2.fileExists(
-    join(repositoryRoot, "pnpm-lock.yaml")
-  );
-  if (pnpmResult.isOk() && pnpmResult.value) return "pnpm";
-  const yarnResult = await repositoryReader2.fileExists(
-    join(repositoryRoot, "yarn.lock")
-  );
-  if (yarnResult.isOk() && yarnResult.value) return "yarn";
-  const npmResult = await repositoryReader2.fileExists(
-    join(repositoryRoot, "package-lock.json")
-  );
-  if (npmResult.isOk() && npmResult.value) return "npm";
-  return void 0;
-};
-var detectPackageManager = async (dependencies, repositoryRoot) => {
-  const packageJsonResult = await dependencies.packageJsonReader.readPackageJson(repositoryRoot);
-  const packageManager = packageJsonResult.map((pkg) => pkg.packageManager).unwrapOr(void 0) ?? await detectFromLockFile(dependencies, repositoryRoot);
-  return packageManager ?? "npm";
-};
-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 = async (dependencies, repositoryRoot) => {
-  const packageJsonResult = await dependencies.packageJsonReader.readPackageJson(repositoryRoot);
-  return packageJsonResult.map((pkg) => pkg.devDependencies.get("turbo")?.trim()).unwrapOr(void 0);
-};
-var getInfo = (dependencies) => async () => {
-  const repositoryRoot = await dependencies.repositoryReader.findRepositoryRoot().unwrapOr(process.cwd());
-  return {
-    node: await detectNodeVersion(
-      { repositoryReader: dependencies.repositoryReader },
-      `${repositoryRoot}/.node-version`
-    ),
-    packageManager: await detectPackageManager(dependencies, repositoryRoot),
-    terraform: await detectTerraformVersion(
-      { repositoryReader: dependencies.repositoryReader },
-      `${repositoryRoot}/.terraform-version`
-    ),
-    turbo: await detectTurboVersion(dependencies, repositoryRoot)
-  };
-};
-var printInfo = (result) => {
-  const logger = getLogger6("json");
-  logger.info(JSON.stringify(result));
-};
-
-// src/adapters/commander/commands/info.ts
-var makeInfoCommand = (dependencies) => new Command3().name("info").description("Display information about the project").action(async () => {
-  const result = await getInfo(dependencies)();
-  printInfo(result);
-});
-
-// src/adapters/commander/commands/init.ts
-import loadMonorepoScaffolder, {
-  answersSchema,
-  PLOP_MONOREPO_GENERATOR_NAME
-} from "@pagopa/monorepo-generator";
-import chalk from "chalk";
-import { Command as Command4 } from "commander";
-import { $ as $3 } from "execa";
-import { errAsync, okAsync as okAsync2, ResultAsync as ResultAsync6 } from "neverthrow";
-import * as path from "path";
-import { oraPromise } from "ora";
-
-// src/domain/github.ts
-var PullRequest = class {
-  constructor(url) {
-    this.url = url;
-  }
-};
-var Repository = class {
-  constructor(name, owner) {
-    this.name = name;
-    this.owner = owner;
-  }
-  get fullName() {
-    return `${this.owner}/${this.name}`;
-  }
-  get ssh() {
-    return `git@github.com:${this.owner}/${this.name}.git`;
-  }
-  get url() {
-    return `https://github.com/${this.owner}/${this.name}`;
-  }
-};
-var RepositoryNotFoundError = class extends Error {
-  constructor(owner, name) {
-    super(`Repository ${owner}/${name} not found`);
-    this.name = "RepositoryNotFoundError";
-  }
-};
-
-// src/adapters/execa/terraform.ts
-import { $ as $2 } from "execa";
-var tf$ = $2({
-  environment: {
-    NO_COLOR: "1",
-    TF_IN_AUTOMATION: "1",
-    TF_INPUT: "0"
-  },
-  shell: true
-});
-
-// src/adapters/plop/index.ts
-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 getPrompts = (generator) => ResultAsync4.fromPromise(
-  generator.runPrompts(),
-  (cause) => new Error("Failed to run the generator prompts", { cause })
-);
-
-// src/adapters/zod/index.ts
-import { ResultAsync as ResultAsync5 } from "neverthrow";
-var decode = (schema) => (data) => ResultAsync5.fromPromise(
-  schema.parseAsync(data),
-  (cause) => new Error("Input is not valid for the given schema", { cause })
-);
-
-// src/adapters/commander/commands/init.ts
-var withSpinner = (text, successText, failText, promise) => ResultAsync6.fromPromise(
-  oraPromise(promise, {
-    failText,
-    successText,
-    text
-  }),
-  (cause) => {
-    console.error(`Something went wrong: ${JSON.stringify(cause, null, 2)}`);
-    return new Error(failText, { cause });
-  }
-);
-var validateAnswers = (githubService) => (answers) => ResultAsync6.fromPromise(
-  githubService.getRepository(answers.repoOwner, answers.repoName),
-  (error) => error
-).andThen(
-  ({ fullName }) => errAsync(new Error(`Repository ${fullName} already exists.`))
-).orElse(
-  (error) => error instanceof RepositoryNotFoundError ? (
-    // If repository is not found, it's safe to proceed
-    okAsync2(answers)
-  ) : (
-    // Otherwise, propagate the error
-    errAsync(error)
-  )
-).map(() => answers);
-var runGeneratorActions = (generator) => (answers) => withSpinner(
-  "Creating workspace files...",
-  "Workspace files created successfully!",
-  "Failed to create workspace files.",
-  generator.runActions(answers)
-).map(() => answers);
-var displaySummary = (initResult) => {
-  const { csp, pr, repository } = initResult;
-  console.log(chalk.green.bold("\nWorkspace created successfully!"));
-  console.log(`- Cloud Service Provider: ${chalk.cyan(csp.name)}`);
-  console.log(`- CSP location: ${chalk.cyan(csp.location)}`);
-  if (repository) {
-    console.log(`- Name: ${chalk.cyan(repository.name)}`);
-    console.log(`- GitHub Repository: ${chalk.cyan(repository.url)}
-`);
-  } else {
-    console.log(
-      chalk.yellow(
-        `
-\u26A0\uFE0F GitHub repository may not have been created automatically.`
-      )
-    );
-  }
-  if (pr) {
-    console.log(chalk.green.bold("\nNext Steps:"));
-    console.log(
-      `1. Review the Pull Request in the GitHub repository: ${chalk.underline(pr.url)}`
-    );
-    console.log(
-      `2. Visit ${chalk.underline("https://dx.pagopa.it/getting-started")} to deploy your first project
-`
-    );
-  } else {
-    console.log(
-      chalk.yellow(`
-\u26A0\uFE0F There was an error during Pull Request creation.`)
-    );
-    console.log(
-      `Please, manually create a Pull Request in the GitHub repository to review the scaffolded code.
-`
-    );
-  }
-};
-var checkTerraformCliIsInstalled = (text, successText, failText) => withSpinner(text, successText, failText, tf$`terraform -version`);
-var checkPreconditions = () => checkTerraformCliIsInstalled(
-  "Checking Terraform CLI is installed...",
-  "Terraform CLI is installed!",
-  "Terraform CLI is not installed."
-);
-var createRemoteRepository = ({
-  repoName,
-  repoOwner
-}) => {
-  const cwd2 = path.resolve(repoName, "infra", "repository");
-  const applyTerraform = async () => {
-    await tf$({ cwd: cwd2 })`terraform init`;
-    await tf$({ cwd: cwd2 })`terraform apply -auto-approve`;
-  };
-  return withSpinner(
-    "Creating GitHub repository...",
-    "GitHub repository created successfully!",
-    "Failed to create GitHub repository.",
-    applyTerraform()
-  ).map(() => new Repository(repoName, repoOwner));
-};
-var initializeGitRepository = (repository) => {
-  const cwd2 = path.resolve(repository.name);
-  const branchName = "features/scaffold-workspace";
-  const git$ = $3({
-    cwd: cwd2,
-    shell: true
-  });
-  const pushToOrigin = async () => {
-    await git$`git init`;
-    await git$`git add README.md`;
-    await git$`git commit --no-gpg-sign -m "Create README.md"`;
-    await git$`git branch -M main`;
-    await git$`git remote add origin ${repository.ssh}`;
-    await git$`git push -u origin main`;
-    await git$`git switch -c ${branchName}`;
-    await git$`git add .`;
-    await git$`git commit --no-gpg-sign -m "Scaffold workspace"`;
-    await git$`git push -u origin ${branchName}`;
-  };
-  return withSpinner(
-    "Pushing code to GitHub...",
-    "Code pushed to GitHub successfully!",
-    "Failed to push code to GitHub.",
-    pushToOrigin()
-  ).map(() => ({ branchName, repository }));
-};
-var handleNewGitHubRepository = (githubService) => (answers) => createRemoteRepository(answers).andThen(initializeGitRepository).andThen(
-  (localWorkspace) => createPullRequest(githubService)(localWorkspace).map((pr) => ({
-    pr,
-    repository: localWorkspace.repository
-  }))
-);
-var makeInitResult = (answers, { pr, repository }) => {
-  const csp = {
-    location: answers.csp === "azure" ? answers.azureLocation : answers.awsRegion,
-    name: answers.csp
-  };
-  return {
-    csp,
-    pr,
-    repository
-  };
-};
-var createPullRequest = (githubService) => ({
-  branchName,
-  repository
-}) => withSpinner(
-  "Creating Pull Request...",
-  "Pull Request created successfully!",
-  "Failed to create Pull Request.",
-  githubService.createPullRequest({
-    base: "main",
-    body: "This PR contains the scaffolded monorepo structure.",
-    head: branchName,
-    owner: repository.owner,
-    repo: repository.name,
-    title: "Scaffold repository"
-  })
-).orElse(() => okAsync2(void 0));
-var makeInitCommand = ({
-  gitHubService: gitHubService2
-}) => 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 checkPreconditions().andThen(initPlop).andTee(loadMonorepoScaffolder).andThen((plop) => getGenerator(plop)(PLOP_MONOREPO_GENERATOR_NAME)).andThen(
-      (generator) => (
-        // Ask the user the questions defined in the plop generator
-        getPrompts(generator).andThen(decode(answersSchema)).andThen(validateAnswers(gitHubService2)).andThen(runGeneratorActions(generator))
-      )
-    ).andThen(
-      (answers) => handleNewGitHubRepository(gitHubService2)(answers).map(
-        (repoPr) => makeInitResult(answers, repoPr)
-      )
-    ).match(displaySummary, exitWithError(this));
-  })
-);
-
-// src/adapters/commander/commands/savemoney.ts
-import { azure, loadConfig } from "@pagopa/dx-savemoney";
-import { Command as Command5 } from "commander";
-var makeSavemoneyCommand = () => new Command5("savemoney").description(
-  "Analyze Azure subscriptions and report unused or inefficient resources"
-).option("-c, --config <path>", "Path to configuration file (JSON)").option(
-  "-f, --format <format>",
-  "Report format: json, table, or detailed-json (default: table)",
-  "table"
-).option(
-  "-l, --location <string>",
-  "Preferred Azure location for resources",
-  "italynorth"
-).option("-d, --days <number>", "Number of days for metrics analysis", "30").option("-v, --verbose", "Enable verbose logging").action(async function(options) {
-  try {
-    const config2 = await loadConfig(options.config);
-    const finalConfig = {
-      ...config2,
-      preferredLocation: options.location || config2.preferredLocation,
-      timespanDays: Number.parseInt(options.days, 10) || config2.timespanDays,
-      verbose: options.verbose || false
-    };
-    await azure.analyzeAzureResources(finalConfig, options.format);
-  } catch (error) {
-    this.error(
-      `Analysis failed: ${error instanceof Error ? error.message : error}`
-    );
-  }
-});
-
-// src/adapters/commander/index.ts
-var makeCli = (deps2, config2, cliDeps) => {
-  const program2 = new Command6();
-  program2.name("dx").description("The CLI for DX-Platform").version("0.15.2");
-  program2.addCommand(makeDoctorCommand(deps2, config2));
-  program2.addCommand(makeCodemodCommand(cliDeps));
-  program2.addCommand(makeInitCommand(deps2));
-  program2.addCommand(makeSavemoneyCommand());
-  program2.addCommand(makeInfoCommand(deps2));
-  return program2;
-};
-var exitWithError = (command) => (error) => {
-  command.error(error.message);
-};
-
-// src/adapters/logtape/validation-reporter.ts
-import { getLogger as getLogger7 } from "@logtape/logtape";
-var makeValidationReporter = () => {
-  const logger = getLogger7(["dx-cli", "validation"]);
-  return {
-    reportCheckResult(result) {
-      if (result.isValid) {
-        logger.info(`\u2705 ${result.successMessage}`);
-      } else {
-        logger.error(`\u274C ${result.errorMessage}`);
-      }
-    }
-  };
-};
-
-// src/adapters/node/package-json.ts
-import { join as join2 } from "path";
-import * as process3 from "process";
-
-// src/adapters/node/fs/file-reader.ts
-import { ResultAsync as ResultAsync7 } from "neverthrow";
-import fs3 from "fs/promises";
-
-// src/adapters/node/json/index.ts
-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) => ResultAsync7.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 = (path3) => ResultAsync7.fromPromise(
-  fs3.stat(path3),
-  () => new Error(`${path3} not found.`)
-).map(() => true);
-
-// src/adapters/node/package-json.ts
-var makePackageJsonReader = () => ({
-  getDependencies: (cwd2 = process3.cwd(), type) => {
-    const packageJsonPath = join2(cwd2, "package.json");
-    return readFileAndDecode(packageJsonPath, packageJsonSchema).map(
-      (packageJson) => {
-        const key = type === "dev" ? "devDependencies" : "dependencies";
-        return packageJson[key];
-      }
-    );
-  },
-  getRootRequiredScripts: () => (/* @__PURE__ */ new Map()).set("code-review", "eslint ."),
-  getScripts: (cwd2 = process3.cwd()) => {
-    const packageJsonPath = join2(cwd2, "package.json");
-    return readFileAndDecode(packageJsonPath, packageJsonSchema).map(
-      ({ scripts }) => scripts
-    );
-  },
-  readPackageJson: (cwd2 = process3.cwd()) => {
-    const packageJsonPath = join2(cwd2, "package.json");
-    return readFileAndDecode(packageJsonPath, packageJsonSchema);
-  }
-});
-
-// src/adapters/node/repository.ts
-import * as glob from "glob";
-import { okAsync as okAsync3, ResultAsync as ResultAsync8 } from "neverthrow";
-import * as path2 from "path";
-import { z as z3 } from "zod/v4";
-
-// src/adapters/yaml/index.ts
-import { Result as Result3 } from "neverthrow";
-import yaml from "yaml";
-var parseYaml = Result3.fromThrowable(
-  (content) => yaml.parse(content),
-  () => new Error("Failed to parse YAML")
-);
-
-// src/adapters/node/repository.ts
-var findRepositoryRoot = (dir = process.cwd()) => {
-  const gitPath = path2.join(dir, ".git");
-  return fileExists(gitPath).mapErr(
-    () => new Error(
-      "Could not find repository root. Make sure to have the repo initialized."
-    )
-  ).map(() => dir);
-};
-var resolveWorkspacePattern = (repoRoot, pattern) => ResultAsync8.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: repoRoot }),
-  (cause) => new Error(`Failed to resolve workspace glob: ${pattern}`, {
-    cause
-  })
-).map(
-  (subDirectories) => (
-    // Create the absolute path to the subdirectory
-    subDirectories.map((directory) => path2.join(repoRoot, directory))
-  )
-);
-var getWorkspaces = (repoRoot) => readFile(path2.join(repoRoot, "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: [] })
-    )
-  )
-).andThen(
-  ({ packages }) => (
-    // For every package pattern in the pnpm-workspace.yaml file, get the list of subdirectories
-    ResultAsync8.combine(
-      packages.map((pattern) => resolveWorkspacePattern(repoRoot, pattern))
-    ).map((workspacesList) => workspacesList.flat()).andThen((workspaceFolders) => {
-      const workspaceResults = workspaceFolders.map(
-        (nodeWorkspaceDirectory) => readFileAndDecode(
-          path2.join(nodeWorkspaceDirectory, "package.json"),
-          packageJsonSchema
-        ).map(
-          ({ name }) => (
-            // Create the workspace object using the package.json name and the nodeWorkspaceDirectory
-            workspaceSchema.parse({ name, path: nodeWorkspaceDirectory })
-          )
-        )
-      );
-      return ResultAsync8.combine(workspaceResults);
-    })
-  )
-);
-var makeRepositoryReader = () => ({
-  fileExists,
-  findRepositoryRoot,
-  getWorkspaces,
-  readFile
-});
-
-// src/adapters/octokit/index.ts
-import { RequestError } from "octokit";
-var OctokitGitHubService = class {
-  #octokit;
-  constructor(octokit2) {
-    this.#octokit = octokit2;
-  }
-  async createPullRequest(params) {
-    try {
-      const { data } = await this.#octokit.rest.pulls.create({
-        base: params.base,
-        body: params.body,
-        head: params.head,
-        owner: params.owner,
-        repo: params.repo,
-        title: params.title
-      });
-      return new PullRequest(data.html_url);
-    } catch (error) {
-      throw new Error(
-        `Failed to create pull request in ${params.owner}/${params.repo}`,
-        {
-          cause: error
-        }
-      );
-    }
-  }
-  async getRepository(owner, name) {
-    try {
-      const { data } = await this.#octokit.rest.repos.get({
-        owner,
-        repo: name
-      });
-      return new Repository(data.name, data.owner.login);
-    } catch (error) {
-      if (error instanceof RequestError && error.status === 404) {
-        throw new RepositoryNotFoundError(owner, name);
-      }
-      throw new Error(`Failed to fetch repository ${owner}/${name}`, {
-        cause: error
-      });
-    }
-  }
-};
-
-// src/config.ts
-var getConfig = () => ({
-  minVersions: {
-    turbo: "2"
-  }
-});
-
-// src/use-cases/apply-codemod.ts
-import { errAsync as errAsync2, okAsync as okAsync4, ResultAsync as ResultAsync9 } from "neverthrow";
-var getCodemodById = (registry2, id) => registry2.getById(id).andThen(
-  (codemod) => codemod ? okAsync4(codemod) : errAsync2(new Error(`Codemod with id ${id} not found`))
-);
-var safeGetInfo = (getInfo2) => ResultAsync9.fromPromise(
-  getInfo2(),
-  (error) => new Error("Failed to get info", { cause: error })
-);
-var applyCodemodById = (registry2, getInfo2) => (id) => ResultAsync9.combine([
-  safeGetInfo(getInfo2),
-  getCodemodById(registry2, id)
-]).andThen(
-  ([info, codemod]) => ResultAsync9.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();
-
-// src/index.ts
 await configure({
   loggers: [
     { category: ["dx-cli"], lowestLevel: "info", sinks: ["console"] },
@@ -1266,33 +12,15 @@ await configure({
     {
       category: ["logtape", "meta"],
       lowestLevel: "warning",
-      sinks: ["console"]
-    }
+      sinks: ["console"],
+    },
   ],
   sinks: {
     console: getConsoleSink(),
     rawJson(record) {
       console.log(record.rawMessage);
-    }
-  }
-});
-var repositoryReader = makeRepositoryReader();
-var packageJsonReader = makePackageJsonReader();
-var validationReporter = makeValidationReporter();
-var octokit = new Octokit3({
-  auth: process.env.GITHUB_TOKEN
+    },
+  },
 });
-var gitHubService = new OctokitGitHubService(octokit);
-var deps = {
-  gitHubService,
-  packageJsonReader,
-  repositoryReader,
-  validationReporter
-};
-var config = getConfig();
-var useCases = {
-  applyCodemodById: applyCodemodById(codemods_default, getInfo(deps)),
-  listCodemods: listCodemods(codemods_default)
-};
-var program = makeCli(deps, config, useCases);
-program.parse();
+
+runCli(packageJson.version);