@iacmp/cli 1.1.0

package/dist/commands/doctor.js

@@ -0,0 +1,191 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  default: () => Doctor
+});
+module.exports = __toCommonJS(doctor_exports);
+var import_core = require("@oclif/core");
+var import_child_process = require("child_process");
+var path = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+
+// src/utils.ts
+var fs = __toESM(require("fs"));
+function readJsonFile(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch (e) {
+    throw new Error(`Falha ao ler '${filePath}': ${errMessage(e)}`);
+  }
+  try {
+    return JSON.parse(content);
+  } catch (e) {
+    throw new Error(`JSON inv\xE1lido em '${filePath}': ${errMessage(e)}`);
+  }
+}
+function errMessage(e) {
+  if (e instanceof Error) return e.message;
+  if (typeof e === "string") return e;
+  try {
+    return JSON.stringify(e);
+  } catch {
+    return String(e);
+  }
+}
+
+// src/commands/doctor.ts
+function tryExec(cmd) {
+  try {
+    return (0, import_child_process.execSync)(cmd, { stdio: "pipe" }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+function checkNode() {
+  const out = tryExec("node --version");
+  if (!out) return { label: "Node.js", ok: false, required: true, hint: "Instale em: https://nodejs.org" };
+  const version = out.replace("v", "");
+  const major = parseInt(version.split(".")[0], 10);
+  return {
+    label: "Node.js",
+    ok: major >= 20,
+    required: true,
+    value: out,
+    hint: major < 20 ? "Node.js 20+ \xE9 necess\xE1rio." : void 0
+  };
+}
+function checkNpm() {
+  const out = tryExec("npm --version");
+  if (!out) return { label: "npm", ok: false, required: true, hint: "Instale Node.js (npm vem junto)." };
+  return { label: "npm", ok: true, required: true, value: `v${out}` };
+}
+function checkIacmp() {
+  const pkgPath = path.resolve(__dirname, "../../package.json");
+  try {
+    const pkg = readJsonFile(pkgPath);
+    return { label: "iacmp", ok: true, required: false, value: `v${pkg.version}` };
+  } catch {
+    return { label: "iacmp", ok: false, required: false, hint: "package.json n\xE3o encontrado" };
+  }
+}
+function checkAwsCli() {
+  const out = tryExec("aws --version");
+  if (!out) return { label: "AWS CLI", ok: false, required: false, hint: "Instale com: brew install awscli" };
+  const version = out.split("/")[1]?.split(" ")[0] ?? out;
+  return { label: "AWS CLI", ok: true, required: false, value: version };
+}
+function checkAnthropicKey() {
+  const key = process.env.ANTHROPIC_API_KEY;
+  return {
+    label: "ANTHROPIC_API_KEY",
+    ok: true,
+    required: false,
+    value: key ? "configurado" : "n\xE3o configurado (necess\xE1rio para iacmp ai)"
+  };
+}
+var Doctor = class _Doctor extends import_core.Command {
+  static description = "Verifica o ambiente e depend\xEAncias do iacmp";
+  static examples = [
+    "$ iacmp doctor",
+    "$ iacmp doctor --strict"
+  ];
+  static flags = {
+    strict: import_core.Flags.boolean({
+      description: "Falha (exit 1) tamb\xE9m para checagens opcionais (AWS CLI, etc.)",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_Doctor);
+    this.log("Verificando ambiente...\n");
+    const checks = [
+      checkNode(),
+      checkNpm(),
+      checkIacmp(),
+      checkAwsCli(),
+      checkAnthropicKey()
+    ];
+    for (const check of checks) {
+      const icon = check.ok ? "\u2713" : "\u2717";
+      const status = check.value ? `${check.label} ${check.value}` : check.label;
+      if (check.ok) {
+        this.log(`  ${icon} ${status}`);
+      } else {
+        this.log(`  ${icon} ${check.label} nao encontrado`);
+        if (check.hint) {
+          this.log(`      ${check.hint}`);
+        }
+      }
+    }
+    this.log("");
+    const allOk = checks.every((c) => c.ok);
+    if (allOk) {
+      this.log("Ambiente OK. Pronto para uso.");
+    } else {
+      this.log("Alguns itens precisam de aten\xE7\xE3o.");
+    }
+    const cwd = process.cwd();
+    const configPath = path.join(cwd, "iacmp.json");
+    if (fs2.existsSync(configPath)) {
+      let config = {};
+      try {
+        config = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+      } catch {
+      }
+      if (config.plugins && config.plugins.length > 0) {
+        this.log("\nPlugins do projeto:");
+        for (const pluginName of config.plugins) {
+          let found = false;
+          let providerNames = [];
+          try {
+            const pluginPath = require.resolve(pluginName, { paths: [cwd] });
+            const mod = require(pluginPath);
+            if (Array.isArray(mod.providers)) {
+              found = true;
+              providerNames = mod.providers.map((p) => p.name);
+            }
+          } catch {
+          }
+          const icon = found ? "\u2713" : "\u2717";
+          const detail = found ? `(providers: ${providerNames.join(", ")})` : "n\xE3o encontrado \u2014 rode npm install";
+          this.log(`  ${icon} ${pluginName} ${detail}`);
+        }
+      }
+    }
+    const requiredFailed = checks.some((c) => c.required && !c.ok);
+    const optionalFailed = checks.some((c) => !c.required && !c.ok);
+    if (requiredFailed || flags.strict && optionalFailed) {
+      this.exit(1);
+    }
+  }
+};

package/dist/commands/init.js

@@ -0,0 +1,507 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  default: () => Init
+});
+module.exports = __toCommonJS(init_exports);
+var import_core = require("@oclif/core");
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var TEMPLATES = {
+  default: {
+    description: "Lambda Hello World exposta via API Gateway REST (arquivos separados)",
+    constructs: ["Fn.Lambda", "Fn.ApiGateway"],
+    stackSubDir: "stacks/compute",
+    stackContent: (name) => `import { Stack, Fn } from '@iacmp/core';
+
+const stack = new Stack('${name}-lambda');
+
+new Fn.Lambda(stack, 'HelloWorldFn', {
+  runtime: 'nodejs20',
+  handler: 'index.handler',
+  code: 'dist/',
+  memory: 128,
+  timeout: 10,
+});
+
+export default stack;
+`,
+    extraFiles: [
+      {
+        path: "stacks/network/api-gateway-stack.ts",
+        content: (name) => `import { Stack, Fn } from '@iacmp/core';
+
+const stack = new Stack('${name}-api');
+
+new Fn.ApiGateway(stack, 'HelloWorldApi', {
+  name: '${name}-api',
+  type: 'REST',
+  stageName: 'prod',
+  cors: true,
+  authType: 'NONE',
+  routes: [
+    {
+      method: 'GET',
+      path: '/hello',
+      lambdaId: 'HelloWorldFn',
+    },
+  ],
+});
+
+export default stack;
+`
+      }
+    ]
+  },
+  rds: {
+    description: "Banco de dados RDS (postgres) com VPC Multi-AZ e r\xE9plica de leitura",
+    constructs: ["Network.VPC", "Database.SQL (principal)", "Database.SQL (replica)"],
+    stackContent: (name) => `import { Stack, Network, Database } from '@iacmp/core';
+
+const stack = new Stack('${name}');
+
+new Network.VPC(stack, 'VPC', {
+  cidr: '10.0.0.0/16',
+  maxAzs: 3,
+});
+
+new Database.SQL(stack, 'Principal', {
+  engine: 'postgres',
+  instanceType: 'medium',
+  multiAz: true,
+});
+
+new Database.SQL(stack, 'Replica', {
+  engine: 'postgres',
+  instanceType: 'small',
+  multiAz: false,
+});
+
+export default stack;
+`
+  },
+  webapp: {
+    description: "Site est\xE1tico com VPC, bucket p\xFAblico e bucket privado de assets",
+    constructs: ["Network.VPC", "Storage.Bucket (site p\xFAblico)", "Storage.Bucket (assets privados)"],
+    stackContent: (name) => `import { Stack, Network, Storage } from '@iacmp/core';
+
+const stack = new Stack('${name}');
+
+new Network.VPC(stack, 'Rede', {
+  cidr: '10.0.0.0/16',
+});
+
+new Storage.Bucket(stack, 'SiteBucket', {
+  versioning: false,
+  publicAccess: true,
+});
+
+new Storage.Bucket(stack, 'AssetsBucket', {
+  versioning: true,
+  publicAccess: false,
+});
+
+export default stack;
+`
+  },
+  network: {
+    description: "Infraestrutura de rede completa com VPC multi-AZ, bastion e app server",
+    constructs: ["Network.VPC", "Compute.Instance (bastion)", "Compute.Instance (app server)"],
+    stackContent: (name) => `import { Stack, Network, Compute } from '@iacmp/core';
+
+const stack = new Stack('${name}');
+
+new Network.VPC(stack, 'VpcPrincipal', {
+  cidr: '10.0.0.0/8',
+  maxAzs: 3,
+});
+
+new Compute.Instance(stack, 'Bastion', {
+  instanceType: 'small',
+  image: 'ubuntu-22.04',
+});
+
+new Compute.Instance(stack, 'AppServer', {
+  instanceType: 'large',
+  image: 'ubuntu-22.04',
+});
+
+export default stack;
+`
+  },
+  serverless: {
+    description: "API serverless com m\xFAltiplas Lambdas e API Gateway",
+    constructs: ["Fn.Lambda", "Fn.ApiGateway"],
+    stackSubDir: "stacks/compute",
+    stackContent: (name) => `import { Stack, Fn } from '@iacmp/core';
+
+const stack = new Stack('${name}');
+
+new Fn.Lambda(stack, 'HelloFn', {
+  runtime: 'nodejs20',
+  handler: 'index.handler',
+  code: 'dist/',
+  memory: 256,
+  timeout: 30,
+});
+
+new Fn.Lambda(stack, 'UsersFn', {
+  runtime: 'nodejs20',
+  handler: 'index.handler',
+  code: 'dist/',
+  memory: 256,
+  timeout: 30,
+});
+
+export default stack;
+`,
+    extraFiles: [
+      {
+        path: "stacks/network/api-gateway-stack.ts",
+        content: (name) => `import { Stack, Fn } from '@iacmp/core';
+
+const stack = new Stack('${name}-api');
+
+new Fn.ApiGateway(stack, 'Api', {
+  name: '${name}-api',
+  type: 'REST',
+  stageName: 'prod',
+  cors: true,
+  authType: 'NONE',
+  routes: [
+    { method: 'GET', path: '/hello', lambdaId: 'HelloFn' },
+    { method: 'GET', path: '/users', lambdaId: 'UsersFn' },
+    { method: 'POST', path: '/users', lambdaId: 'UsersFn' },
+  ],
+});
+
+export default stack;
+`
+      }
+    ]
+  },
+  fullstack: {
+    description: "Aplica\xE7\xE3o completa: VPC, compute, banco postgres e bucket",
+    constructs: ["Network.VPC", "Compute.Instance", "Database.SQL", "Storage.Bucket"],
+    stackContent: (name) => `import { Stack, Network, Compute, Database, Storage } from '@iacmp/core';
+
+const stack = new Stack('${name}');
+
+new Network.VPC(stack, 'VPC', {
+  cidr: '10.0.0.0/16',
+  maxAzs: 3,
+});
+
+new Compute.Instance(stack, 'App', {
+  instanceType: 'medium',
+  image: 'ubuntu-22.04',
+});
+
+new Database.SQL(stack, 'DB', {
+  engine: 'postgres',
+  instanceType: 'medium',
+  multiAz: true,
+});
+
+new Storage.Bucket(stack, 'Uploads', {
+  versioning: true,
+  publicAccess: false,
+});
+
+export default stack;
+`
+  }
+};
+function testContent(projectName, stackFile) {
+  return `import { Stack } from '@iacmp/core';
+import stack from '../stacks/${stackFile}';
+
+test('${projectName} stack tem pelo menos um construct', () => {
+  expect(stack).toBeInstanceOf(Stack);
+  expect(stack.constructs.length).toBeGreaterThan(0);
+});
+`;
+}
+function packageJson(projectName, coreVersion) {
+  return JSON.stringify({
+    name: projectName,
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      build: "tsc",
+      watch: "tsc -w",
+      test: "jest",
+      synth: "iacmp synth",
+      deploy: "iacmp deploy"
+    },
+    dependencies: {
+      "@iacmp/core": `^${coreVersion}`
+    },
+    devDependencies: {
+      "@types/jest": "^30",
+      "@types/node": "^22",
+      jest: "^30",
+      "ts-jest": "^29",
+      "ts-node": "^10",
+      typescript: "~5.5.0"
+    },
+    jest: {
+      preset: "ts-jest",
+      testEnvironment: "node"
+    }
+  }, null, 2) + "\n";
+}
+function tsConfig() {
+  return JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "CommonJS",
+      moduleResolution: "node",
+      lib: ["es2022"],
+      declaration: true,
+      strict: true,
+      noImplicitAny: true,
+      strictNullChecks: true,
+      noImplicitReturns: true,
+      experimentalDecorators: true,
+      strictPropertyInitialization: false,
+      skipLibCheck: true,
+      outDir: "dist",
+      rootDir: "."
+      // @iacmp/core é resolvido via node_modules após `npm install`
+    },
+    exclude: ["node_modules", "dist"]
+  }, null, 2) + "\n";
+}
+function gitignore() {
+  return ["node_modules/", "dist/", "synth-out/", "audit/", "*.js.map", "*.d.ts", ".DS_Store", ".env", ".iacmp/"].join("\n") + "\n";
+}
+function dotenv() {
+  return `# Chave da API Anthropic \u2014 necess\xE1ria para usar iacmp ai
+ANTHROPIC_API_KEY=
+
+# Token do GitHub Copilot (alternativa ao Anthropic)
+# GITHUB_TOKEN=
+`;
+}
+function githubActionsYml() {
+  return `name: iacmp
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  synth:
+    name: Synth & Validate
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm install -g iacmp
+      - run: iacmp synth
+      - run: npm test
+`;
+}
+function gitlabCiYml() {
+  return `image: node:20
+
+stages:
+  - validate
+
+synth:
+  stage: validate
+  cache:
+    paths:
+      - node_modules/
+  script:
+    - npm ci
+    - npm install -g iacmp
+    - iacmp synth
+    - npm test
+`;
+}
+var PYTHON_PLACEHOLDER = `# iacmp \u2014 Stack Python (suporte completo dispon\xEDvel na Fase 4)
+#
+# from iacmp_core import Stack, Compute, Storage
+#
+# stack = Stack("minha-stack")
+# Compute.Instance(stack, "Web", { "instanceType": "small", "image": "ubuntu-22.04" })
+`;
+var Init = class _Init extends import_core.Command {
+  static description = "Inicializa um novo projeto iacmp. Se um nome for passado, cria a pasta do projeto.";
+  static args = {
+    name: import_core.Args.string({ description: "Nome do projeto (cria a pasta automaticamente)", required: false })
+  };
+  static flags = {
+    language: import_core.Flags.string({ char: "l", description: "Linguagem (typescript, python)", default: "typescript" }),
+    provider: import_core.Flags.string({ char: "p", description: "Provider padr\xE3o (aws, azure, gcp, terraform)", default: "aws" }),
+    template: import_core.Flags.string({
+      char: "t",
+      description: `Template de stack a usar (default, rds, webapp, network, serverless, fullstack)`,
+      default: "default"
+    }),
+    list: import_core.Flags.boolean({ description: "Lista os templates dispon\xEDveis", default: false })
+  };
+  static examples = [
+    "$ iacmp init meu-projeto",
+    "$ iacmp init meu-projeto --template rds",
+    "$ iacmp init meu-projeto --template webapp --provider azure",
+    "$ iacmp init meu-projeto --template serverless",
+    "$ iacmp init meu-projeto --template fullstack",
+    "$ iacmp init --list"
+  ];
+  async run() {
+    const { args, flags } = await this.parse(_Init);
+    if (flags.list) {
+      this.log("\nTemplates dispon\xEDveis:\n");
+      const nameWidth = Math.max(...Object.keys(TEMPLATES).map((k) => k.length)) + 2;
+      for (const [name, tpl] of Object.entries(TEMPLATES)) {
+        this.log(`  ${name.padEnd(nameWidth)} ${tpl.description}`);
+        for (const c of tpl.constructs) {
+          this.log(`  ${" ".repeat(nameWidth)}   \xB7 ${c}`);
+        }
+        this.log("");
+      }
+      this.log(`Uso: iacmp init meu-projeto --template <nome>`);
+      return;
+    }
+    const validLanguages = ["typescript", "python"];
+    if (!validLanguages.includes(flags.language)) {
+      this.error(`Linguagem '${flags.language}' n\xE3o suportada. Use: ${validLanguages.join(", ")}`);
+    }
+    const validProviders = ["aws", "azure", "gcp", "terraform"];
+    if (!validProviders.includes(flags.provider)) {
+      this.error(`Provider '${flags.provider}' n\xE3o suportado. Use: ${validProviders.join(", ")}`);
+    }
+    const template = TEMPLATES[flags.template];
+    if (!template) {
+      const available = Object.keys(TEMPLATES).join(", ");
+      this.error(`Template '${flags.template}' n\xE3o encontrado. Dispon\xEDveis: ${available}
+
+Use 'iacmp init --list' para ver todos os templates.`);
+    }
+    const cwd = process.cwd();
+    const projectName = args.name ?? path.basename(cwd);
+    const projectDir = args.name ? path.join(cwd, args.name) : cwd;
+    if (args.name) {
+      if (fs.existsSync(projectDir)) {
+        this.error(`A pasta '${args.name}' j\xE1 existe.`);
+      }
+      fs.mkdirSync(projectDir, { recursive: true });
+    } else {
+      if (fs.existsSync(path.join(projectDir, "iacmp.json"))) {
+        this.error(`Projeto j\xE1 inicializado em ${path.join(projectDir, "iacmp.json")}`);
+      }
+    }
+    const config = { name: projectName, provider: flags.provider, region: "us-east-1", language: flags.language };
+    fs.writeFileSync(path.join(projectDir, "iacmp.json"), JSON.stringify(config, null, 2) + "\n");
+    fs.writeFileSync(path.join(projectDir, ".gitignore"), gitignore());
+    fs.writeFileSync(path.join(projectDir, ".env"), dotenv());
+    const stacksDir = path.join(projectDir, "stacks");
+    fs.mkdirSync(stacksDir, { recursive: true });
+    const stackFileName = `${projectName}-stack.ts`;
+    if (flags.language === "typescript") {
+      const coreVersion = (() => {
+        try {
+          const corePkgJson = require.resolve("@iacmp/core/package.json");
+          return JSON.parse(fs.readFileSync(corePkgJson, "utf-8")).version;
+        } catch {
+          return "1.0.0";
+        }
+      })();
+      fs.writeFileSync(path.join(projectDir, "package.json"), packageJson(projectName, coreVersion));
+      fs.writeFileSync(path.join(projectDir, "tsconfig.json"), tsConfig());
+      const stackSubDir = template.stackSubDir ? path.join(projectDir, template.stackSubDir) : stacksDir;
+      fs.mkdirSync(stackSubDir, { recursive: true });
+      fs.writeFileSync(path.join(stackSubDir, stackFileName), template.stackContent(projectName));
+      if (template.extraFiles) {
+        for (const extra of template.extraFiles) {
+          const extraPath = path.join(projectDir, extra.path);
+          fs.mkdirSync(path.dirname(extraPath), { recursive: true });
+          fs.writeFileSync(extraPath, extra.content(projectName));
+        }
+      }
+      const testDir = path.join(projectDir, "test");
+      fs.mkdirSync(testDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(testDir, `${projectName}.test.ts`),
+        testContent(projectName, `${projectName}-stack`)
+      );
+      const githubWorkflowsDir = path.join(projectDir, ".github", "workflows");
+      fs.mkdirSync(githubWorkflowsDir, { recursive: true });
+      fs.writeFileSync(path.join(githubWorkflowsDir, "iacmp.yml"), githubActionsYml());
+      fs.writeFileSync(path.join(projectDir, ".gitlab-ci.yml"), gitlabCiYml());
+    } else {
+      fs.writeFileSync(path.join(stacksDir, "exemplo_stack.py"), PYTHON_PLACEHOLDER);
+    }
+    try {
+      (0, import_child_process.execSync)("git init", { cwd: projectDir, stdio: "pipe" });
+    } catch {
+    }
+    const rel = args.name ?? ".";
+    const isDefault = flags.template === "default";
+    const templateLabel = isDefault ? "" : ` (template: ${flags.template})`;
+    this.log(`
+Projeto '${projectName}' inicializado${templateLabel}.
+`);
+    this.log(`  ${rel}/iacmp.json`);
+    this.log(`  ${rel}/.env`);
+    if (flags.language === "typescript") {
+      this.log(`  ${rel}/package.json`);
+      this.log(`  ${rel}/tsconfig.json`);
+      const stackRelPath = template.stackSubDir ? `${template.stackSubDir}/${stackFileName}` : `stacks/${stackFileName}`;
+      this.log(`  ${rel}/${stackRelPath}`);
+      this.log(`  ${rel}/test/${projectName}.test.ts`);
+      this.log(`  ${rel}/.github/workflows/iacmp.yml`);
+      this.log(`  ${rel}/.gitlab-ci.yml`);
+    }
+    if (!isDefault) {
+      this.log(`
+Recursos inclu\xEDdos:`);
+      for (const c of template.constructs) {
+        this.log(`  \xB7 ${c}`);
+      }
+    }
+    this.log("\nPr\xF3ximos passos:");
+    if (args.name) this.log(`  cd ${args.name}`);
+    this.log("  npm install");
+    this.log("  iacmp synth");
+  }
+};