@pagopa/dx-cli 0.11.2 → 0.14.0

package/README.md

@@ -112,19 +112,43 @@ This command helps you:
 
 #### `init`
 
-Initialize resources such as new projects with standardized structure.
+Bootstrap a new monorepo project with standardized structure and remote repository provisioning.
 
 ```bash
-# Initialize a new monorepo project
 dx init project
 ```
 
 This command will:
 
-- Guide you through creating a new monorepo project
-- Set up the project structure according to PagoPA's DevEx guidelines
-- Configure necessary tools and dependencies
-- Bootstrap the project with best practices
+- Check that required tools (e.g., Terraform CLI) are installed
+- Interactively prompt for project metadata (cloud provider, region, environments, cost center, etc.)
+- Generate a monorepo structure following PagoPA DevEx guidelines
+- Create a remote GitHub repository using Terraform
+- Push the initial codebase to the newly created repository
+
+**Example usage:**
+
+```bash
+$ dx init project
+? What is the repository name? my-monorepo
+? What is the GitHub repository owner? pagopa
+? What is the repository description? My new PagoPA monorepo
+...
+
+✔ Terraform CLI is installed!
+✔ Workspace files created successfully!
+✔ GitHub repository created successfully!
+✔ Code pushed to GitHub successfully!
+
+Workspace created successfully!
+- Name: my-monorepo
+- Cloud Service Provider: azure
+- CSP location: italynorth
+- GitHub Repository: https://github.com/pagopa/my-monorepo
+```
+
+> [!NOTE]
+> The command will fail early if required tools are missing.
 
 #### `info`
 

package/bin/index.js

@@ -3,6 +3,7 @@
 // src/index.ts
 import "core-js/actual/set/index.js";
 import { configure, getConsoleSink } from "@logtape/logtape";
+import { Octokit as Octokit2 } from "octokit";
 
 // src/adapters/codemods/registry.ts
 import { okAsync } from "neverthrow";
@@ -31,8 +32,8 @@ import * as YAML2 from "yaml";
 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({
+  const octokit2 = new Octokit();
+  const response = await octokit2.rest.repos.getCommit({
     owner,
     ref,
     repo
@@ -52,8 +53,8 @@ var getLatestCommitShaOrRef = async (owner, repo, ref = "main") => {
 
 // src/adapters/codemods/yaml.ts
 import * as YAML from "yaml";
-var isChildOf = (path2, key) => {
-  const ancestor = path2.at(-1);
+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;
 };
 
@@ -63,8 +64,8 @@ var updateJSCodeReviewJob = (sha) => (workflow, filename) => {
   const document = YAML2.parseDocument(workflow);
   let updated = false;
   YAML2.visit(document, {
-    Map(_, map, path2) {
-      if (map.has("jobs") || isChildOf(path2, "jobs")) {
+    Map(_, map, path3) {
+      if (map.has("jobs") || isChildOf(path3, "jobs")) {
         return void 0;
       }
       if (map.has("uses")) {
@@ -127,8 +128,8 @@ var migrateWorkflow = (sha) => (workflow, filename) => {
   const document = YAML3.parseDocument(workflow);
   let updated = false;
   YAML3.visit(document, {
-    Map(_, map, path2) {
-      if (isChildOf(path2, "jobs") || isChildOf(path2, "with")) {
+    Map(_, map, path3) {
+      if (isChildOf(path3, "jobs") || isChildOf(path3, "with")) {
         return void 0;
       }
       if (map.has("jobs")) {
@@ -740,8 +741,29 @@ var makeInfoCommand = (dependencies) => new Command3().name("info").description(
 });
 
 // src/adapters/commander/commands/init.ts
-import scaffoldMonorepo from "@pagopa/monorepo-generator";
+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 { okAsync as okAsync2, ResultAsync as ResultAsync6 } from "neverthrow";
+import * as path from "path";
+import { oraPromise } from "ora";
+
+// 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(
@@ -752,24 +774,180 @@ var getGenerator = (plopAPI) => Result.fromThrowable(
   plopAPI.getGenerator,
   () => new Error("Generator not found")
 );
-var runGenerator = (generator) => ResultAsync4.fromPromise(
+var getPrompts = (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")
-  )
+  (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 Repository = class {
+  constructor(name, owner) {
+    this.name = name;
+    this.owner = owner;
+  }
+  get ssh() {
+    return `git@github.com:${this.owner}/${this.name}.git`;
+  }
+  get url() {
+    return `https://github.com/${this.owner}/${this.name}`;
+  }
+};
+var withSpinner = (text, successText, failText, promise) => ResultAsync6.fromPromise(
+  oraPromise(promise, {
+    failText,
+    successText,
+    text
+  }),
+  (cause) => new Error(failText, { cause })
 );
-var makeInitCommand = () => new Command4().name("init").description(
+var validateAnswers = (answers) => okAsync2(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 = (octokit2) => (answers) => createRemoteRepository(answers).andThen(initializeGitRepository).andThen(
+  (localWorkspace) => createPullRequest(octokit2)(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 = (octokit2) => ({
+  branchName,
+  repository
+}) => withSpinner(
+  "Creating Pull Request...",
+  "Pull Request created successfully!",
+  "Failed to create Pull Request.",
+  octokit2.rest.pulls.create({
+    base: "main",
+    body: "This PR contains the scaffolded monorepo structure.",
+    head: branchName,
+    owner: repository.owner,
+    repo: repository.name,
+    title: "Scaffold repository"
+  })
+).map(({ data }) => ({ url: data.html_url })).orElse(() => okAsync2(void 0));
+var makeInitCommand = ({
+  octokit: octokit2
+}) => 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);
-    });
+    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).andThen(runGeneratorActions(generator))
+      )
+    ).andThen(
+      (answers) => handleNewGitHubRepository(octokit2)(answers).map(
+        (repoPr) => makeInitResult(answers, repoPr)
+      )
+    ).match(displaySummary, exitWithError(this));
   })
 );
 
@@ -806,14 +984,17 @@ var makeSavemoneyCommand = () => new Command5("savemoney").description(
 // 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.11.2");
+  program2.name("dx").description("The CLI for DX-Platform").version("0.14.0");
   program2.addCommand(makeDoctorCommand(deps2, config2));
   program2.addCommand(makeCodemodCommand(cliDeps));
-  program2.addCommand(makeInitCommand());
+  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";
@@ -835,16 +1016,9 @@ import { join as join2 } from "path";
 import * as process3 from "process";
 
 // src/adapters/node/fs/file-reader.ts
-import { ResultAsync as ResultAsync6 } from "neverthrow";
+import { ResultAsync as ResultAsync7 } from "neverthrow";
 import fs3 from "fs/promises";
 
-// src/adapters/zod/index.ts
-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 as Result2 } from "neverthrow";
 var parseJson = Result2.fromThrowable(
@@ -853,14 +1027,14 @@ var parseJson = Result2.fromThrowable(
 );
 
 // src/adapters/node/fs/file-reader.ts
-var readFile2 = (filePath) => ResultAsync6.fromPromise(
+var readFile2 = (filePath) => ResultAsync7.fromPromise(
   fs3.readFile(filePath, "utf-8"),
   (cause) => new Error(`Failed to read file: ${filePath}`, { cause })
 );
 var readFileAndDecode = (filePath, schema) => readFile2(filePath).andThen(parseJson).andThen(decode(schema));
-var fileExists = (path2) => ResultAsync6.fromPromise(
-  fs3.stat(path2),
-  () => new Error(`${path2} not found.`)
+var fileExists = (path3) => ResultAsync7.fromPromise(
+  fs3.stat(path3),
+  () => new Error(`${path3} not found.`)
 ).map(() => true);
 
 // src/adapters/node/package-json.ts
@@ -889,8 +1063,8 @@ var makePackageJsonReader = () => ({
 
 // src/adapters/node/repository.ts
 import * as glob from "glob";
-import { okAsync as okAsync2, ResultAsync as ResultAsync7 } from "neverthrow";
-import * as path from "path";
+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
@@ -903,14 +1077,14 @@ var parseYaml = Result3.fromThrowable(
 
 // src/adapters/node/repository.ts
 var findRepositoryRoot = (dir = process.cwd()) => {
-  const gitPath = path.join(dir, ".git");
+  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) => ResultAsync7.fromPromise(
+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 }),
@@ -920,25 +1094,25 @@ var resolveWorkspacePattern = (repoRoot, pattern) => ResultAsync7.fromPromise(
 ).map(
   (subDirectories) => (
     // Create the absolute path to the subdirectory
-    subDirectories.map((directory) => path.join(repoRoot, directory))
+    subDirectories.map((directory) => path2.join(repoRoot, directory))
   )
 );
-var getWorkspaces = (repoRoot) => readFile2(path.join(repoRoot, "pnpm-workspace.yaml")).andThen(parseYaml).andThen(
+var getWorkspaces = (repoRoot) => readFile2(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(
-      () => okAsync2({ packages: [] })
+      () => okAsync3({ packages: [] })
     )
   )
 ).andThen(
   ({ packages }) => (
     // For every package pattern in the pnpm-workspace.yaml file, get the list of subdirectories
-    ResultAsync7.combine(
+    ResultAsync8.combine(
       packages.map((pattern) => resolveWorkspacePattern(repoRoot, pattern))
     ).map((workspacesList) => workspacesList.flat()).andThen((workspaceFolders) => {
       const workspaceResults = workspaceFolders.map(
         (nodeWorkspaceDirectory) => readFileAndDecode(
-          path.join(nodeWorkspaceDirectory, "package.json"),
+          path2.join(nodeWorkspaceDirectory, "package.json"),
           packageJsonSchema
         ).map(
           ({ name }) => (
@@ -947,7 +1121,7 @@ var getWorkspaces = (repoRoot) => readFile2(path.join(repoRoot, "pnpm-workspace.
           )
         )
       );
-      return ResultAsync7.combine(workspaceResults);
+      return ResultAsync8.combine(workspaceResults);
     })
   )
 );
@@ -966,19 +1140,19 @@ var getConfig = () => ({
 });
 
 // src/use-cases/apply-codemod.ts
-import { errAsync, okAsync as okAsync3, ResultAsync as ResultAsync8 } from "neverthrow";
+import { errAsync, okAsync as okAsync4, ResultAsync as ResultAsync9 } from "neverthrow";
 var getCodemodById = (registry2, id) => registry2.getById(id).andThen(
-  (codemod) => codemod ? okAsync3(codemod) : errAsync(new Error(`Codemod with id ${id} not found`))
+  (codemod) => codemod ? okAsync4(codemod) : errAsync(new Error(`Codemod with id ${id} not found`))
 );
-var safeGetInfo = (getInfo2) => ResultAsync8.fromPromise(
+var safeGetInfo = (getInfo2) => ResultAsync9.fromPromise(
   getInfo2(),
   (error) => new Error("Failed to get info", { cause: error })
 );
-var applyCodemodById = (registry2, getInfo2) => (id) => ResultAsync8.combine([
+var applyCodemodById = (registry2, getInfo2) => (id) => ResultAsync9.combine([
   safeGetInfo(getInfo2),
   getCodemodById(registry2, id)
 ]).andThen(
-  ([info, codemod]) => ResultAsync8.fromPromise(codemod.apply(info), (error) => {
+  ([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 });
   })
@@ -1009,7 +1183,11 @@ await configure({
 var repositoryReader = makeRepositoryReader();
 var packageJsonReader = makePackageJsonReader();
 var validationReporter = makeValidationReporter();
+var octokit = new Octokit2({
+  auth: process.env.GITHUB_TOKEN
+});
 var deps = {
+  octokit,
   packageJsonReader,
   repositoryReader,
   validationReporter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-cli",
-  "version": "0.11.2",
+  "version": "0.14.0",
   "type": "module",
   "description": "A CLI useful to manage DX tools.",
   "repository": {
@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "@logtape/logtape": "^1.2.2",
+    "chalk": "^5.6.2",
     "commander": "^14.0.2",
     "core-js": "^3.47.0",
     "execa": "^9.6.1",
@@ -27,12 +28,13 @@
     "neverthrow": "^8.2.0",
     "node-plop": "^0.32.3",
     "octokit": "^5.0.5",
+    "ora": "^9.0.0",
     "replace-in-file": "^8.3.0",
     "semver": "^7.7.2",
     "yaml": "^2.8.2",
-    "zod": "^3.25.76",
+    "zod": "^4.1.13",
     "@pagopa/dx-savemoney": "^0.1.4",
-    "@pagopa/monorepo-generator": "^0.11.2"
+    "@pagopa/monorepo-generator": "^0.13.0"
   },
   "devDependencies": {
     "@tsconfig/node22": "22.0.2",