plazercli 1.0.0

package/dist/index.js

@@ -0,0 +1,4059 @@
+#!/usr/bin/env node
+
+// src/cli/args.ts
+import { Command } from "commander";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var pkgPath = path.resolve(__dirname, "../package.json");
+var pkgPathAlt = path.resolve(__dirname, "../../package.json");
+var pkg = JSON.parse(
+  (() => {
+    try {
+      return readFileSync(pkgPath, "utf-8");
+    } catch {
+      return readFileSync(pkgPathAlt, "utf-8");
+    }
+  })()
+);
+function parseArgs() {
+  const program = new Command();
+  program.name("plazercli").description("CLI para gerar projetos fullstack boilerplate").version(pkg.version, "-v, --version").option("-n, --name <name>", "Nome do projeto").option("-y, --yes", "Usar valores padr\xE3o (skip prompts)").parse();
+  const opts = program.opts();
+  return {
+    name: opts.name,
+    yes: opts.yes
+  };
+}
+
+// src/cli/prompts.ts
+import { input, select, confirm, checkbox } from "@inquirer/prompts";
+import path2 from "path";
+async function runPrompts(flags) {
+  const projectName = flags.name ?? await input({
+    message: "\u{1F4E6} Qual o nome do projeto?",
+    validate: (value) => {
+      if (!value.trim()) return "O nome do projeto \xE9 obrigat\xF3rio";
+      if (!/^[a-z0-9-]+$/.test(value)) return "Use apenas letras min\xFAsculas, n\xFAmeros e h\xEDfens";
+      return true;
+    }
+  });
+  const projectDescription = await input({
+    message: "\u{1F4DD} Descreva brevemente o projeto:",
+    default: `Projeto ${projectName}`
+  });
+  const runtime = await select({
+    message: "\u26A1 Qual runtime/gerenciador de pacotes usar?",
+    choices: [
+      { name: "pnpm (Recomendado)", value: "pnpm" },
+      { name: "bun", value: "bun" },
+      { name: "npm", value: "npm" }
+    ]
+  });
+  const database = await select({
+    message: "\u{1F5C4}\uFE0F  Qual banco de dados usar?",
+    choices: [
+      { name: "PostgreSQL", value: "postgresql" },
+      { name: "MySQL", value: "mysql" },
+      { name: "MongoDB", value: "mongodb" },
+      { name: "Nenhum", value: "none" }
+    ]
+  });
+  const multiTenant = await confirm({
+    message: "\u{1F3E2} Usar multi-tenant?",
+    default: false
+  });
+  let smtp = await confirm({
+    message: "\u{1F4E7} Configurar servidor SMTP (envio de emails)?",
+    default: false
+  });
+  const authChoices = await checkbox({
+    message: "\u{1F510} Quais m\xE9todos de autentica\xE7\xE3o usar?",
+    choices: [
+      { name: "JWT (JSON Web Token)", value: "jwt" },
+      { name: "Magic Link (login por email)", value: "magicLink" },
+      { name: "Google OAuth", value: "googleOAuth" }
+    ]
+  });
+  const auth = {
+    jwt: authChoices.includes("jwt"),
+    magicLink: authChoices.includes("magicLink"),
+    googleOAuth: authChoices.includes("googleOAuth")
+  };
+  if (auth.magicLink && !smtp) {
+    smtp = true;
+    console.log("  \u2139 SMTP habilitado automaticamente (necess\xE1rio para Magic Link)");
+  }
+  let redis = await confirm({
+    message: "\u{1F534} Usar Redis (cache/sess\xF5es)?",
+    default: false
+  });
+  const queue = await select({
+    message: "\u{1F4EC} Usar filas e jobs?",
+    choices: [
+      { name: "BullMQ (requer Redis)", value: "bullmq" },
+      { name: "RabbitMQ", value: "rabbitmq" },
+      { name: "Nenhum", value: "none" }
+    ]
+  });
+  if (queue === "bullmq" && !redis) {
+    redis = true;
+    console.log("  \u2139 Redis habilitado automaticamente (necess\xE1rio para BullMQ)");
+  }
+  const frontend = await select({
+    message: "\u{1F3A8} Qual framework de frontend?",
+    choices: [
+      { name: "Next.js", value: "nextjs" },
+      { name: "React (Vite)", value: "react-vite" },
+      { name: "Vue", value: "vue" },
+      { name: "Angular", value: "angular" }
+    ]
+  });
+  const backend = await select({
+    message: "\u{1F527} Qual framework de backend?",
+    choices: [
+      { name: "Express", value: "express" },
+      { name: "Fastify", value: "fastify" },
+      { name: "NestJS", value: "nestjs" }
+    ]
+  });
+  const integrationChoices = await checkbox({
+    message: "\u{1F50C} Quais integra\xE7\xF5es usar?",
+    choices: [
+      { name: "ViaCEP (consulta CEP)", value: "viacep" },
+      { name: "WhatsApp", value: "whatsapp" },
+      { name: "Stripe (pagamentos)", value: "stripe" },
+      { name: "Mercado Pago (pagamentos)", value: "mercadoPago" },
+      { name: "AbacatePay (pagamentos)", value: "abacatePay" }
+    ]
+  });
+  const integrations = {
+    viacep: integrationChoices.includes("viacep"),
+    whatsapp: integrationChoices.includes("whatsapp"),
+    stripe: integrationChoices.includes("stripe"),
+    mercadoPago: integrationChoices.includes("mercadoPago"),
+    abacatePay: integrationChoices.includes("abacatePay")
+  };
+  const minio = await confirm({
+    message: "\u{1F4E6} Usar MinIO para storage (S3-compatible)?",
+    default: false
+  });
+  const pm2 = await confirm({
+    message: "\u{1F504} Usar PM2 para atualiza\xE7\xF5es sem downtime?",
+    default: false
+  });
+  const projectDir = path2.resolve(process.cwd(), projectName);
+  const usePrisma = database === "postgresql" || database === "mysql";
+  const useMongoose = database === "mongodb";
+  const hasAnyAuth = auth.jwt || auth.magicLink || auth.googleOAuth;
+  const hasAnyIntegration = Object.values(integrations).some(Boolean);
+  const hasAnyQueue = queue !== "none";
+  return {
+    projectName,
+    projectDescription,
+    runtime,
+    database,
+    multiTenant,
+    smtp,
+    redis,
+    minio,
+    pm2,
+    auth,
+    queue,
+    frontend,
+    backend,
+    integrations,
+    projectDir,
+    usePrisma,
+    useMongoose,
+    hasAnyAuth,
+    hasAnyIntegration,
+    hasAnyQueue
+  };
+}
+
+// src/helpers/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (msg) => console.log(chalk.cyan("  \u2139"), msg),
+  success: (msg) => console.log(chalk.green("  \u2714"), msg),
+  warn: (msg) => console.log(chalk.yellow("  \u26A0"), msg),
+  error: (msg) => console.log(chalk.red("  \u2716"), msg),
+  step: (msg) => console.log(chalk.blue("  \u2192"), msg),
+  title: (msg) => console.log(chalk.bold.white(`
+  ${msg}
+`)),
+  blank: () => console.log()
+};
+function printBanner() {
+  console.log(
+    chalk.bold.cyan(`
+  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+  \u2551                                               \u2551
+  \u2551          \u{1F680}  PlazerCLI  v1.0                  \u2551
+  \u2551     Fullstack Boilerplate Generator           \u2551
+  \u2551                                               \u2551
+  \u2551     Oi! Eu sou a Liz, sua assistente.         \u2551
+  \u2551     Vou configurar seu projeto inteiro.       \u2551
+  \u2551                                               \u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`)
+  );
+}
+function printSummary(config) {
+  const authMethods = [
+    config.auth.jwt && "JWT",
+    config.auth.magicLink && "Magic Link",
+    config.auth.googleOAuth && "Google OAuth"
+  ].filter(Boolean);
+  const integrations = Object.entries(config.integrations).filter(([, v]) => v).map(([k]) => k);
+  const infra = [
+    config.redis && "Redis",
+    config.smtp && "SMTP",
+    config.minio && "MinIO",
+    config.pm2 && "PM2",
+    config.multiTenant && "Multi-tenant"
+  ].filter(Boolean);
+  console.log(chalk.bold.white("\n  \u{1F4CB} Liz preparou o resumo do projeto:\n"));
+  console.log(chalk.white(`  Projeto:       ${chalk.cyan(config.projectName)}`));
+  console.log(chalk.white(`  Frontend:      ${chalk.cyan(config.frontend)}`));
+  console.log(chalk.white(`  Backend:       ${chalk.cyan(config.backend)}`));
+  console.log(chalk.white(`  Banco de dados: ${chalk.cyan(config.database)}`));
+  if (authMethods.length > 0) {
+    console.log(chalk.white(`  Autentica\xE7\xE3o:  ${chalk.cyan(authMethods.join(", "))}`));
+  }
+  if (config.queue !== "none") {
+    console.log(chalk.white(`  Filas:         ${chalk.cyan(config.queue)}`));
+  }
+  if (infra.length > 0) {
+    console.log(chalk.white(`  Infra:         ${chalk.cyan(infra.join(", "))}`));
+  }
+  if (integrations.length > 0) {
+    console.log(chalk.white(`  Integra\xE7\xF5es:   ${chalk.cyan(integrations.join(", "))}`));
+  }
+  console.log();
+}
+
+// src/generators/project.ts
+import path30 from "path";
+import chalk2 from "chalk";
+
+// src/generators/base.ts
+import path4 from "path";
+
+// src/helpers/filesystem.ts
+import fs from "fs-extra";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
+var TEMPLATE_DIR = fs.existsSync(path3.resolve(__dirname2, "../../templates")) ? path3.resolve(__dirname2, "../../templates") : path3.resolve(__dirname2, "../templates");
+function getTemplatePath(...segments) {
+  return path3.join(TEMPLATE_DIR, ...segments);
+}
+async function ensureDir(dir) {
+  await fs.ensureDir(dir);
+}
+async function copyFile(src, dest) {
+  await fs.ensureDir(path3.dirname(dest));
+  await fs.copyFile(src, dest);
+}
+async function writeFile(filePath, content) {
+  await fs.ensureDir(path3.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function readFile(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+
+// src/helpers/template.ts
+import ejs from "ejs";
+async function renderTemplate(templatePath, data) {
+  const template = await readFile(templatePath);
+  return ejs.render(template, data, { async: false });
+}
+
+// src/helpers/runtime.ts
+import { execa } from "execa";
+function getInstallCommand(runtime) {
+  switch (runtime) {
+    case "bun":
+      return ["bun", ["install"]];
+    case "pnpm":
+      return ["pnpm", ["install"]];
+    case "npm":
+      return ["npm", ["install"]];
+  }
+}
+function getRunCommand(runtime) {
+  switch (runtime) {
+    case "bun":
+      return "bun run";
+    case "pnpm":
+      return "pnpm run";
+    case "npm":
+      return "npm run";
+  }
+}
+async function isCommandAvailable(cmd) {
+  try {
+    await execa("which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installDependencies(projectDir, runtime) {
+  const [cmd, args] = getInstallCommand(runtime);
+  if (await isCommandAvailable(cmd)) {
+    await execa(cmd, args, { cwd: projectDir, stdio: "pipe" });
+    return { success: true };
+  }
+  const fallbacks = ["npm", "pnpm", "bun"];
+  for (const fb of fallbacks) {
+    if (fb === runtime) continue;
+    const [fbCmd, fbArgs] = getInstallCommand(fb);
+    if (await isCommandAvailable(fbCmd)) {
+      await execa(fbCmd, fbArgs, { cwd: projectDir, stdio: "pipe" });
+      return { success: true, fallback: fb };
+    }
+  }
+  return { success: false };
+}
+
+// src/generators/base.ts
+async function generateBase(config) {
+  const { projectDir, projectName, projectDescription, runtime } = config;
+  await ensureDir(projectDir);
+  await ensureDir(path4.join(projectDir, "apps"));
+  await ensureDir(path4.join(projectDir, "apps", "api"));
+  await ensureDir(path4.join(projectDir, "apps", "web"));
+  const runCmd = getRunCommand(runtime);
+  const packageJsonTemplate = getTemplatePath("base", "root", "package.json.ejs");
+  const packageJsonContent = await renderTemplate(packageJsonTemplate, {
+    projectName,
+    projectDescription,
+    runCmd
+  });
+  await writeFile(path4.join(projectDir, "package.json"), packageJsonContent);
+  await copyFile(
+    getTemplatePath("base", "root", "gitignore"),
+    path4.join(projectDir, ".gitignore")
+  );
+  await copyFile(
+    getTemplatePath("base", "root", "editorconfig"),
+    path4.join(projectDir, ".editorconfig")
+  );
+  await copyFile(
+    getTemplatePath("base", "root", "nvmrc"),
+    path4.join(projectDir, ".nvmrc")
+  );
+  if (runtime === "pnpm") {
+    await copyFile(
+      getTemplatePath("base", "root", "pnpm-workspace.yaml"),
+      path4.join(projectDir, "pnpm-workspace.yaml")
+    );
+  }
+}
+
+// src/generators/frontend.ts
+import path5 from "path";
+
+// src/installers/dependencyVersionMap.ts
+var dependencyVersionMap = {
+  // Prisma
+  "prisma": "^6.3.0",
+  "@prisma/client": "^6.3.0",
+  // Mongoose
+  "mongoose": "^8.9.0",
+  // Auth
+  "jsonwebtoken": "^9.0.2",
+  "@types/jsonwebtoken": "^9.0.7",
+  "bcryptjs": "^2.4.3",
+  "@types/bcryptjs": "^2.4.6",
+  "passport": "^0.7.0",
+  "passport-jwt": "^4.0.1",
+  "@types/passport-jwt": "^4.0.1",
+  "passport-google-oauth20": "^2.0.0",
+  "@types/passport-google-oauth20": "^2.0.16",
+  "@nestjs/jwt": "^11.0.0",
+  "@nestjs/passport": "^11.0.0",
+  "nanoid": "^5.0.9",
+  // Queues
+  "bullmq": "^5.30.0",
+  "@nestjs/bullmq": "^11.0.0",
+  "amqplib": "^0.10.5",
+  "@types/amqplib": "^0.10.6",
+  // Redis
+  "ioredis": "^5.4.0",
+  // SMTP
+  "nodemailer": "^6.9.0",
+  "@types/nodemailer": "^6.4.17",
+  // Storage
+  "minio": "^8.0.0",
+  // Integrations
+  "axios": "^1.7.0",
+  "stripe": "^17.4.0",
+  "mercadopago": "^2.0.0",
+  // Express
+  "express": "^4.21.0",
+  "@types/express": "^4.17.21",
+  "cors": "^2.8.5",
+  "@types/cors": "^2.8.17",
+  "helmet": "^8.0.0",
+  "dotenv": "^16.4.0",
+  // Fastify
+  "@fastify/cors": "^10.0.0",
+  "@fastify/helmet": "^12.0.0",
+  "fastify": "^5.0.0",
+  // NestJS
+  "@nestjs/common": "^11.0.0",
+  "@nestjs/core": "^11.0.0",
+  "@nestjs/platform-express": "^11.0.0",
+  "@nestjs/config": "^4.0.0",
+  "@nestjs/cli": "^11.0.0",
+  "reflect-metadata": "^0.2.2",
+  "rxjs": "^7.8.1",
+  // Next.js
+  "next": "^15.0.0",
+  "react": "^19.0.0",
+  "react-dom": "^19.0.0",
+  "@types/react": "^19.0.0",
+  "@types/react-dom": "^19.0.0",
+  // Vue
+  "vue": "^3.5.0",
+  "vue-router": "^4.5.0",
+  "@vitejs/plugin-vue": "^5.0.0",
+  // Angular
+  "@angular/core": "^19.0.0",
+  "@angular/cli": "^19.0.0",
+  // Common
+  "typescript": "^5.7.0",
+  "vite": "^6.0.0",
+  "@types/node": "^22.10.0",
+  "tsx": "^4.19.0",
+  "pm2": "^5.4.0"
+};
+
+// src/generators/frontend.ts
+async function generateFrontend(config, webDir) {
+  switch (config.frontend) {
+    case "nextjs":
+      await generateNextjs(config, webDir);
+      break;
+    case "react-vite":
+      await generateReactVite(config, webDir);
+      break;
+    case "vue":
+      await generateVue(config, webDir);
+      break;
+    case "angular":
+      await generateAngular(config, webDir);
+      break;
+  }
+}
+async function generateNextjs(config, webDir) {
+  await ensureDir(path5.join(webDir, "src", "app"));
+  await ensureDir(path5.join(webDir, "public"));
+  await writeFile(path5.join(webDir, "package.json"), JSON.stringify({
+    name: `@${config.projectName}/web`,
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      dev: "next dev",
+      build: "next build",
+      start: "next start",
+      lint: "next lint"
+    },
+    dependencies: {
+      next: dependencyVersionMap.next,
+      react: dependencyVersionMap.react,
+      "react-dom": dependencyVersionMap["react-dom"]
+    },
+    devDependencies: {
+      "@types/node": dependencyVersionMap["@types/node"],
+      "@types/react": dependencyVersionMap["@types/react"],
+      "@types/react-dom": dependencyVersionMap["@types/react-dom"],
+      typescript: dependencyVersionMap.typescript
+    }
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2017",
+      lib: ["dom", "dom.iterable", "esnext"],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: "esnext",
+      moduleResolution: "bundler",
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: "preserve",
+      incremental: true,
+      plugins: [{ name: "next" }],
+      paths: { "@/*": ["./src/*"] }
+    },
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+    exclude: ["node_modules"]
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "next.config.ts"), `import type { NextConfig } from 'next';
+
+const nextConfig: NextConfig = {};
+
+export default nextConfig;
+`);
+  await writeFile(path5.join(webDir, "src", "app", "layout.tsx"), `import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = {
+  title: '${config.projectName}',
+  description: '${config.projectDescription}',
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="pt-BR">
+      <body>{children}</body>
+    </html>
+  );
+}
+`);
+  await writeFile(path5.join(webDir, "src", "app", "page.tsx"), `export default function Home() {
+  return (
+    <main style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', minHeight: '100vh', fontFamily: 'system-ui' }}>
+      <h1>${config.projectName}</h1>
+      <p>${config.projectDescription}</p>
+      <p style={{ marginTop: '2rem', color: '#666' }}>
+        API rodando em <a href="http://localhost:3001" style={{ color: '#0070f3' }}>http://localhost:3001</a>
+      </p>
+    </main>
+  );
+}
+`);
+  await writeFile(path5.join(webDir, "src", "app", "globals.css"), `* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: system-ui, -apple-system, sans-serif;
+  -webkit-font-smoothing: antialiased;
+}
+
+a {
+  color: inherit;
+  text-decoration: none;
+}
+`);
+}
+async function generateReactVite(config, webDir) {
+  await ensureDir(path5.join(webDir, "src"));
+  await ensureDir(path5.join(webDir, "public"));
+  await writeFile(path5.join(webDir, "package.json"), JSON.stringify({
+    name: `@${config.projectName}/web`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "tsc -b && vite build",
+      preview: "vite preview"
+    },
+    dependencies: {
+      react: dependencyVersionMap.react,
+      "react-dom": dependencyVersionMap["react-dom"]
+    },
+    devDependencies: {
+      "@types/react": dependencyVersionMap["@types/react"],
+      "@types/react-dom": dependencyVersionMap["@types/react-dom"],
+      "@vitejs/plugin-react": "^4.3.0",
+      typescript: dependencyVersionMap.typescript,
+      vite: dependencyVersionMap.vite
+    }
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2020",
+      useDefineForClassFields: true,
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      module: "ESNext",
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      isolatedModules: true,
+      noEmit: true,
+      jsx: "react-jsx",
+      strict: true
+    },
+    include: ["src"]
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "vite.config.ts"), `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 3000,
+  },
+});
+`);
+  await writeFile(path5.join(webDir, "index.html"), `<!doctype html>
+<html lang="pt-BR">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${config.projectName}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`);
+  await writeFile(path5.join(webDir, "src", "main.tsx"), `import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+import './index.css';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
+`);
+  await writeFile(path5.join(webDir, "src", "App.tsx"), `function App() {
+  return (
+    <main style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', minHeight: '100vh', fontFamily: 'system-ui' }}>
+      <h1>${config.projectName}</h1>
+      <p>${config.projectDescription}</p>
+      <p style={{ marginTop: '2rem', color: '#666' }}>
+        API rodando em <a href="http://localhost:3001" style={{ color: '#0070f3' }}>http://localhost:3001</a>
+      </p>
+    </main>
+  );
+}
+
+export default App;
+`);
+  await writeFile(path5.join(webDir, "src", "index.css"), `* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: system-ui, -apple-system, sans-serif;
+  -webkit-font-smoothing: antialiased;
+}
+`);
+}
+async function generateVue(config, webDir) {
+  await ensureDir(path5.join(webDir, "src"));
+  await ensureDir(path5.join(webDir, "public"));
+  await writeFile(path5.join(webDir, "package.json"), JSON.stringify({
+    name: `@${config.projectName}/web`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vue-tsc -b && vite build",
+      preview: "vite preview"
+    },
+    dependencies: {
+      vue: dependencyVersionMap.vue,
+      "vue-router": dependencyVersionMap["vue-router"]
+    },
+    devDependencies: {
+      "@vitejs/plugin-vue": dependencyVersionMap["@vitejs/plugin-vue"],
+      typescript: dependencyVersionMap.typescript,
+      vite: dependencyVersionMap.vite,
+      "vue-tsc": "^2.1.0"
+    }
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2020",
+      module: "ESNext",
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      isolatedModules: true,
+      noEmit: true,
+      jsx: "preserve",
+      strict: true
+    },
+    include: ["src/**/*.ts", "src/**/*.vue"]
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "vite.config.ts"), `import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+
+export default defineConfig({
+  plugins: [vue()],
+  server: {
+    port: 3000,
+  },
+});
+`);
+  await writeFile(path5.join(webDir, "index.html"), `<!doctype html>
+<html lang="pt-BR">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${config.projectName}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`);
+  await writeFile(path5.join(webDir, "src", "main.ts"), `import { createApp } from 'vue';
+import App from './App.vue';
+import './style.css';
+
+createApp(App).mount('#app');
+`);
+  await writeFile(path5.join(webDir, "src", "App.vue"), `<template>
+  <main class="container">
+    <h1>${config.projectName}</h1>
+    <p>${config.projectDescription}</p>
+    <p class="api-link">
+      API rodando em <a href="http://localhost:3001">http://localhost:3001</a>
+    </p>
+  </main>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+  font-family: system-ui;
+}
+.api-link {
+  margin-top: 2rem;
+  color: #666;
+}
+.api-link a {
+  color: #42b883;
+}
+</style>
+`);
+  await writeFile(path5.join(webDir, "src", "style.css"), `* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: system-ui, -apple-system, sans-serif;
+  -webkit-font-smoothing: antialiased;
+}
+`);
+  await writeFile(path5.join(webDir, "env.d.ts"), `/// <reference types="vite/client" />
+`);
+}
+async function generateAngular(config, webDir) {
+  await ensureDir(path5.join(webDir, "src", "app"));
+  await writeFile(path5.join(webDir, "package.json"), JSON.stringify({
+    name: `@${config.projectName}/web`,
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      dev: "ng serve --port 3000",
+      build: "ng build",
+      lint: "ng lint"
+    },
+    dependencies: {
+      "@angular/animations": dependencyVersionMap["@angular/core"],
+      "@angular/common": dependencyVersionMap["@angular/core"],
+      "@angular/compiler": dependencyVersionMap["@angular/core"],
+      "@angular/core": dependencyVersionMap["@angular/core"],
+      "@angular/forms": dependencyVersionMap["@angular/core"],
+      "@angular/platform-browser": dependencyVersionMap["@angular/core"],
+      "@angular/platform-browser-dynamic": dependencyVersionMap["@angular/core"],
+      "@angular/router": dependencyVersionMap["@angular/core"],
+      rxjs: dependencyVersionMap.rxjs,
+      "zone.js": "^0.15.0"
+    },
+    devDependencies: {
+      "@angular/cli": dependencyVersionMap["@angular/cli"],
+      "@angular/compiler-cli": dependencyVersionMap["@angular/core"],
+      typescript: dependencyVersionMap.typescript
+    }
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "ES2022",
+      lib: ["ES2022", "dom"],
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      strict: true,
+      noEmit: false,
+      declaration: false,
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true,
+      outDir: "./dist"
+    },
+    include: ["src/**/*.ts"]
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "angular.json"), JSON.stringify({
+    $schema: "./node_modules/@angular/cli/lib/config/schema.json",
+    version: 1,
+    newProjectRoot: "projects",
+    projects: {
+      web: {
+        projectType: "application",
+        root: "",
+        sourceRoot: "src",
+        architect: {
+          build: {
+            builder: "@angular-devkit/build-angular:application",
+            options: {
+              outputPath: "dist",
+              index: "src/index.html",
+              browser: "src/main.ts",
+              tsConfig: "tsconfig.json"
+            }
+          },
+          serve: {
+            builder: "@angular-devkit/build-angular:dev-server",
+            configurations: {
+              development: { buildTarget: "web:build" }
+            },
+            defaultConfiguration: "development"
+          }
+        }
+      }
+    }
+  }, null, 2) + "\n");
+  await writeFile(path5.join(webDir, "src", "index.html"), `<!doctype html>
+<html lang="pt-BR">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${config.projectName}</title>
+  </head>
+  <body>
+    <app-root></app-root>
+  </body>
+</html>
+`);
+  await writeFile(path5.join(webDir, "src", "main.ts"), `import { bootstrapApplication } from '@angular/platform-browser';
+import { AppComponent } from './app/app.component';
+
+bootstrapApplication(AppComponent).catch((err) => console.error(err));
+`);
+  await writeFile(path5.join(webDir, "src", "app", "app.component.ts"), `import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-root',
+  standalone: true,
+  template: \`
+    <main style="display: flex; flex-direction: column; align-items: center; justify-content: center; min-height: 100vh; font-family: system-ui;">
+      <h1>${config.projectName}</h1>
+      <p>${config.projectDescription}</p>
+      <p style="margin-top: 2rem; color: #666;">
+        API rodando em <a href="http://localhost:3001" style="color: #dd0031;">http://localhost:3001</a>
+      </p>
+    </main>
+  \`,
+})
+export class AppComponent {}
+`);
+  await writeFile(path5.join(webDir, "src", "styles.css"), `* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: system-ui, -apple-system, sans-serif;
+  -webkit-font-smoothing: antialiased;
+}
+`);
+}
+
+// src/generators/backend.ts
+import path6 from "path";
+async function generateBackend(config, apiDir) {
+  switch (config.backend) {
+    case "express":
+      await generateExpress(config, apiDir);
+      break;
+    case "fastify":
+      await generateFastify(config, apiDir);
+      break;
+    case "nestjs":
+      await generateNestjs(config, apiDir);
+      break;
+  }
+}
+async function generateExpress(config, apiDir) {
+  await ensureDir(path6.join(apiDir, "src", "routes"));
+  await ensureDir(path6.join(apiDir, "src", "middlewares"));
+  await ensureDir(path6.join(apiDir, "src", "config"));
+  await writeFile(path6.join(apiDir, "package.json"), JSON.stringify({
+    name: `@${config.projectName}/api`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "tsx watch src/index.ts",
+      build: "tsc",
+      start: "node dist/index.js",
+      lint: "tsc --noEmit"
+    },
+    dependencies: {
+      express: dependencyVersionMap.express,
+      cors: dependencyVersionMap.cors,
+      helmet: dependencyVersionMap.helmet,
+      dotenv: dependencyVersionMap.dotenv
+    },
+    devDependencies: {
+      "@types/express": dependencyVersionMap["@types/express"],
+      "@types/cors": dependencyVersionMap["@types/cors"],
+      "@types/node": dependencyVersionMap["@types/node"],
+      typescript: dependencyVersionMap.typescript,
+      tsx: dependencyVersionMap.tsx
+    }
+  }, null, 2) + "\n");
+  await writeFile(path6.join(apiDir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      esModuleInterop: true,
+      strict: true,
+      outDir: "dist",
+      rootDir: "src",
+      skipLibCheck: true,
+      declaration: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  }, null, 2) + "\n");
+  await writeFile(path6.join(apiDir, "src", "config", "index.ts"), `import 'dotenv/config';
+
+export const config = {
+  port: Number(process.env.PORT) || 3001,
+  nodeEnv: process.env.NODE_ENV || 'development',
+  corsOrigin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+};
+`);
+  await writeFile(path6.join(apiDir, "src", "app.ts"), `import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import { config } from './config/index.js';
+import { router } from './routes/index.js';
+import { errorHandler } from './middlewares/errorHandler.js';
+
+const app = express();
+
+app.use(helmet());
+app.use(cors({ origin: config.corsOrigin }));
+app.use(express.json());
+
+app.use('/api', router);
+
+app.use(errorHandler);
+
+export { app };
+`);
+  await writeFile(path6.join(apiDir, "src", "index.ts"), `import { app } from './app.js';
+import { config } from './config/index.js';
+
+app.listen(config.port, () => {
+  console.log(\`\u{1F680} API rodando em http://localhost:\${config.port}\`);
+});
+`);
+  await writeFile(path6.join(apiDir, "src", "routes", "index.ts"), `import { Router } from 'express';
+
+const router = Router();
+
+router.get('/health', (_req, res) => {
+  res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+
+export { router };
+`);
+  await writeFile(path6.join(apiDir, "src", "middlewares", "errorHandler.ts"), `import type { Request, Response, NextFunction } from 'express';
+
+export function errorHandler(err: Error, _req: Request, res: Response, _next: NextFunction) {
+  console.error(err.stack);
+  res.status(500).json({
+    error: 'Internal Server Error',
+    message: process.env.NODE_ENV === 'development' ? err.message : undefined,
+  });
+}
+`);
+}
+async function generateFastify(config, apiDir) {
+  await ensureDir(path6.join(apiDir, "src", "routes"));
+  await ensureDir(path6.join(apiDir, "src", "plugins"));
+  await ensureDir(path6.join(apiDir, "src", "config"));
+  await writeFile(path6.join(apiDir, "package.json"), JSON.stringify({
+    name: `@${config.projectName}/api`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "tsx watch src/index.ts",
+      build: "tsc",
+      start: "node dist/index.js",
+      lint: "tsc --noEmit"
+    },
+    dependencies: {
+      fastify: dependencyVersionMap.fastify,
+      "@fastify/cors": dependencyVersionMap["@fastify/cors"],
+      "@fastify/helmet": dependencyVersionMap["@fastify/helmet"],
+      dotenv: dependencyVersionMap.dotenv
+    },
+    devDependencies: {
+      "@types/node": dependencyVersionMap["@types/node"],
+      typescript: dependencyVersionMap.typescript,
+      tsx: dependencyVersionMap.tsx
+    }
+  }, null, 2) + "\n");
+  await writeFile(path6.join(apiDir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      esModuleInterop: true,
+      strict: true,
+      outDir: "dist",
+      rootDir: "src",
+      skipLibCheck: true,
+      declaration: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  }, null, 2) + "\n");
+  await writeFile(path6.join(apiDir, "src", "config", "index.ts"), `import 'dotenv/config';
+
+export const config = {
+  port: Number(process.env.PORT) || 3001,
+  host: process.env.HOST || '0.0.0.0',
+  nodeEnv: process.env.NODE_ENV || 'development',
+  corsOrigin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+};
+`);
+  await writeFile(path6.join(apiDir, "src", "app.ts"), `import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import helmet from '@fastify/helmet';
+import { config } from './config/index.js';
+import { registerRoutes } from './routes/index.js';
+
+export async function buildApp() {
+  const app = Fastify({
+    logger: config.nodeEnv === 'development',
+  });
+
+  await app.register(helmet);
+  await app.register(cors, { origin: config.corsOrigin });
+
+  registerRoutes(app);
+
+  return app;
+}
+`);
+  await writeFile(path6.join(apiDir, "src", "index.ts"), `import { buildApp } from './app.js';
+import { config } from './config/index.js';
+
+async function start() {
+  const app = await buildApp();
+
+  await app.listen({ port: config.port, host: config.host });
+  console.log(\`\u{1F680} API rodando em http://localhost:\${config.port}\`);
+}
+
+start().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+`);
+  await writeFile(path6.join(apiDir, "src", "routes", "index.ts"), `import type { FastifyInstance } from 'fastify';
+
+export function registerRoutes(app: FastifyInstance) {
+  app.get('/api/health', async () => {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  });
+}
+`);
+}
+async function generateNestjs(config, apiDir) {
+  await ensureDir(path6.join(apiDir, "src"));
+  await writeFile(path6.join(apiDir, "package.json"), JSON.stringify({
+    name: `@${config.projectName}/api`,
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      dev: "nest start --watch",
+      build: "nest build",
+      start: "node dist/main.js",
+      "start:prod": "node dist/main.js",
+      lint: "tsc --noEmit"
+    },
+    dependencies: {
+      "@nestjs/common": dependencyVersionMap["@nestjs/common"],
+      "@nestjs/core": dependencyVersionMap["@nestjs/core"],
+      "@nestjs/platform-express": dependencyVersionMap["@nestjs/platform-express"],
+      "@nestjs/config": dependencyVersionMap["@nestjs/config"],
+      "reflect-metadata": dependencyVersionMap["reflect-metadata"],
+      rxjs: dependencyVersionMap.rxjs
+    },
+    devDependencies: {
+      "@nestjs/cli": dependencyVersionMap["@nestjs/cli"],
+      "@types/node": dependencyVersionMap["@types/node"],
+      typescript: dependencyVersionMap.typescript
+    }
+  }, null, 2) + "\n");
+  await writeFile(path6.join(apiDir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      module: "commonjs",
+      declaration: true,
+      removeComments: true,
+      emitDecoratorMetadata: true,
+      experimentalDecorators: true,
+      allowSyntheticDefaultImports: true,
+      target: "ES2021",
+      sourceMap: true,
+      outDir: "./dist",
+      rootDir: "./src",
+      strict: true,
+      skipLibCheck: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  }, null, 2) + "\n");
+  await writeFile(path6.join(apiDir, "nest-cli.json"), JSON.stringify({
+    $schema: "https://json.schemastore.org/nest-cli",
+    collection: "@nestjs/schematics",
+    sourceRoot: "src"
+  }, null, 2) + "\n");
+  await writeFile(path6.join(apiDir, "src", "main.ts"), `import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.enableCors({ origin: process.env.CORS_ORIGIN || 'http://localhost:3000' });
+  app.setGlobalPrefix('api');
+
+  const port = process.env.PORT || 3001;
+  await app.listen(port);
+  console.log(\`\u{1F680} API rodando em http://localhost:\${port}\`);
+}
+
+bootstrap();
+`);
+  await writeFile(path6.join(apiDir, "src", "app.module.ts"), `import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+`);
+  await writeFile(path6.join(apiDir, "src", "app.controller.ts"), `import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get('health')
+  getHealth() {
+    return this.appService.getHealth();
+  }
+}
+`);
+  await writeFile(path6.join(apiDir, "src", "app.service.ts"), `import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHealth() {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  }
+}
+`);
+}
+
+// src/generators/docker.ts
+import path7 from "path";
+async function generateDocker(config, projectDir, extraServices) {
+  const services = [];
+  if (config.database === "postgresql") {
+    services.push(`  postgres:
+    image: postgres:16-alpine
+    container_name: ${config.projectName}-postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: ${config.projectName.replace(/-/g, "_")}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data`);
+  }
+  if (config.database === "mysql") {
+    services.push(`  mysql:
+    image: mysql:8
+    container_name: ${config.projectName}-mysql
+    restart: unless-stopped
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: ${config.projectName.replace(/-/g, "_")}
+      MYSQL_USER: user
+      MYSQL_PASSWORD: password
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql`);
+  }
+  if (config.database === "mongodb") {
+    services.push(`  mongodb:
+    image: mongo:7
+    container_name: ${config.projectName}-mongodb
+    restart: unless-stopped
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: root
+      MONGO_INITDB_ROOT_PASSWORD: root
+      MONGO_INITDB_DATABASE: ${config.projectName.replace(/-/g, "_")}
+    ports:
+      - "27017:27017"
+    volumes:
+      - mongodb_data:/data/db`);
+  }
+  if (config.redis) {
+    services.push(`  redis:
+    image: redis:7-alpine
+    container_name: ${config.projectName}-redis
+    restart: unless-stopped
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data`);
+  }
+  if (config.queue === "rabbitmq") {
+    services.push(`  rabbitmq:
+    image: rabbitmq:3-management-alpine
+    container_name: ${config.projectName}-rabbitmq
+    restart: unless-stopped
+    environment:
+      RABBITMQ_DEFAULT_USER: guest
+      RABBITMQ_DEFAULT_PASS: guest
+    ports:
+      - "5672:5672"
+      - "15672:15672"
+    volumes:
+      - rabbitmq_data:/var/lib/rabbitmq`);
+  }
+  if (config.minio) {
+    services.push(`  minio:
+    image: minio/minio
+    container_name: ${config.projectName}-minio
+    restart: unless-stopped
+    command: server /data --console-address ":9001"
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    ports:
+      - "9000:9000"
+      - "9001:9001"
+    volumes:
+      - minio_data:/data`);
+  }
+  services.push(...extraServices);
+  const volumes = [];
+  if (config.database === "postgresql") volumes.push("  postgres_data:");
+  if (config.database === "mysql") volumes.push("  mysql_data:");
+  if (config.database === "mongodb") volumes.push("  mongodb_data:");
+  if (config.redis) volumes.push("  redis_data:");
+  if (config.queue === "rabbitmq") volumes.push("  rabbitmq_data:");
+  if (config.minio) volumes.push("  minio_data:");
+  const content = `services:
+${services.join("\n\n")}
+
+volumes:
+${volumes.join("\n")}
+`;
+  await writeFile(path7.join(projectDir, "docker-compose.yml"), content);
+}
+
+// src/generators/env.ts
+import path8 from "path";
+async function generateEnv(config, apiDir, envEntries) {
+  const baseEntries = [
+    { key: "NODE_ENV", value: "development", category: "App", comment: "Ambiente" },
+    { key: "PORT", value: "3001", category: "App" }
+  ];
+  if (config.database === "postgresql") {
+    baseEntries.push({
+      key: "DATABASE_URL",
+      value: `postgresql://postgres:postgres@localhost:5432/${config.projectName.replace(/-/g, "_")}`,
+      category: "Database"
+    });
+  } else if (config.database === "mysql") {
+    baseEntries.push({
+      key: "DATABASE_URL",
+      value: `mysql://user:password@localhost:3306/${config.projectName.replace(/-/g, "_")}`,
+      category: "Database"
+    });
+  } else if (config.database === "mongodb") {
+    baseEntries.push({
+      key: "MONGODB_URI",
+      value: `mongodb://root:root@localhost:27017/${config.projectName.replace(/-/g, "_")}?authSource=admin`,
+      category: "Database"
+    });
+  }
+  const allEntries = [...baseEntries, ...envEntries];
+  const categories = /* @__PURE__ */ new Map();
+  for (const entry of allEntries) {
+    const cat = entry.category;
+    if (!categories.has(cat)) categories.set(cat, []);
+    categories.get(cat).push(entry);
+  }
+  const lines = [];
+  for (const [category, entries] of categories) {
+    lines.push(`# ${category}`);
+    for (const entry of entries) {
+      if (entry.comment) lines.push(`# ${entry.comment}`);
+      lines.push(`${entry.key}="${entry.value}"`);
+    }
+    lines.push("");
+  }
+  const envContent = lines.join("\n");
+  await writeFile(path8.join(apiDir, ".env"), envContent);
+  await writeFile(path8.join(apiDir, ".env.example"), envContent);
+}
+
+// src/generators/readme.ts
+import path9 from "path";
+async function generateReadme(config, projectDir) {
+  const runCmd = getRunCommand(config.runtime);
+  const hasDocker = config.database !== "none" || config.redis || config.queue === "rabbitmq" || config.minio;
+  const authMethods = [
+    config.auth.jwt && "JWT",
+    config.auth.magicLink && "Magic Link",
+    config.auth.googleOAuth && "Google OAuth"
+  ].filter(Boolean);
+  const integrations = [
+    config.integrations.viacep && "ViaCEP",
+    config.integrations.whatsapp && "WhatsApp",
+    config.integrations.stripe && "Stripe",
+    config.integrations.mercadoPago && "Mercado Pago",
+    config.integrations.abacatePay && "AbacatePay"
+  ].filter(Boolean);
+  const infra = [
+    config.redis && "Redis",
+    config.smtp && "SMTP",
+    config.minio && "MinIO",
+    config.pm2 && "PM2"
+  ].filter(Boolean);
+  let content = `# ${config.projectName}
+
+${config.projectDescription}
+
+> Projeto gerado com [PlazerCLI](https://github.com/pablocarss/plazercli) + Liz AI Agent
+
+## Stack
+
+| Camada | Tecnologia |
+|--------|-----------|
+| Frontend | ${config.frontend} |
+| Backend | ${config.backend} |
+${config.database !== "none" ? `| Banco de dados | ${config.database} ${config.usePrisma ? "(Prisma)" : "(Mongoose)"} |` : ""}
+${authMethods.length > 0 ? `| Autenticacao | ${authMethods.join(", ")} |` : ""}
+${config.queue !== "none" ? `| Filas | ${config.queue} |` : ""}
+${infra.length > 0 ? `| Infraestrutura | ${infra.join(", ")} |` : ""}
+${integrations.length > 0 ? `| Integracoes | ${integrations.join(", ")} |` : ""}
+| Runtime | ${config.runtime} |
+
+## Estrutura
+
+\`\`\`
+${config.projectName}/
+\u251C\u2500\u2500 apps/
+\u2502   \u251C\u2500\u2500 api/                    # Backend ${config.backend}
+\u2502   \u2502   \u251C\u2500\u2500 src/
+${config.usePrisma ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 database/        # Prisma service\n" : ""}${config.useMongoose ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 database/        # Mongoose models\n" : ""}${config.hasAnyAuth ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 auth/            # Autenticacao\n" : ""}${config.redis || config.smtp || config.minio ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 infra/           # Redis, Email, Storage\n" : ""}${config.hasAnyQueue ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 queue/           # Workers e jobs\n" : ""}${config.hasAnyIntegration ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 integrations/    # APIs externas\n" : ""}${config.multiTenant ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 tenant/          # Multi-tenant\n" : ""}\u2502   \u2502   \u2502   \u251C\u2500\u2500 routes/
+\u2502   \u2502   \u2502   \u2514\u2500\u2500 config/
+${config.usePrisma ? "\u2502   \u2502   \u2514\u2500\u2500 prisma/schema.prisma\n" : ""}\u2502   \u2502   \u2514\u2500\u2500 .env
+\u2502   \u2514\u2500\u2500 web/                    # Frontend ${config.frontend}
+\u2502       \u2514\u2500\u2500 src/
+\u251C\u2500\u2500 docker-compose.yml
+\u251C\u2500\u2500 CLAUDE.md                   # Liz config (Claude Code)
+\u251C\u2500\u2500 AGENTS.md                   # Liz config (geral)
+\u2514\u2500\u2500 README.md
+\`\`\`
+
+## Quick Start
+
+\`\`\`bash
+# Pre-requisitos: Node.js >= 20, ${config.runtime}${hasDocker ? ", Docker" : ""}
+`;
+  let step = 1;
+  if (hasDocker) {
+    content += `
+# ${step}. Subir infraestrutura
+docker compose up -d
+`;
+    step++;
+  }
+  if (config.usePrisma) {
+    content += `
+# ${step}. Criar tabelas no banco
+cd apps/api && npx prisma db push && cd ../..
+`;
+    step++;
+  }
+  content += `
+# ${step}. Iniciar em modo desenvolvimento
+${runCmd} dev
+\`\`\`
+
+Pronto! Frontend em **http://localhost:3000** e API em **http://localhost:3001**
+`;
+  if (config.hasAnyAuth) {
+    content += `
+## Autenticacao
+
+### Endpoints
+`;
+    if (config.auth.jwt) {
+      content += `
+**JWT:**
+- \`POST /api/auth/register\` - Criar conta
+  \`\`\`json
+  { "email": "user@email.com", "password": "123456", "name": "Nome" }
+  \`\`\`
+- \`POST /api/auth/login\` - Login (retorna access_token)
+  \`\`\`json
+  { "email": "user@email.com", "password": "123456" }
+  \`\`\`
+- Header: \`Authorization: Bearer <token>\`
+`;
+    }
+    if (config.auth.magicLink) {
+      content += `
+**Magic Link:**
+- \`POST /api/auth/magic-link/send\` - Enviar link por email
+  \`\`\`json
+  { "email": "user@email.com" }
+  \`\`\`
+- \`GET /api/auth/magic-link/verify?token=xxx\` - Verificar token
+`;
+    }
+    if (config.auth.googleOAuth) {
+      content += `
+**Google OAuth:**
+- \`GET /api/auth/google\` - Redireciona para login Google
+- \`GET /api/auth/google/callback\` - Callback (configurar no Google Console)
+`;
+    }
+  }
+  if (config.hasAnyIntegration) {
+    content += `
+## Integracoes
+`;
+    if (config.integrations.viacep) {
+      content += `
+### ViaCEP
+Servico em \`apps/api/src/integrations/viacep/\`
+\`\`\`typescript
+import { fetchAddress } from './integrations/viacep/viacep.service';
+const endereco = await fetchAddress('01001000');
+\`\`\`
+`;
+    }
+    if (config.integrations.stripe) {
+      content += `
+### Stripe
+Configurar \`STRIPE_SECRET_KEY\` e \`STRIPE_WEBHOOK_SECRET\` no .env
+\`\`\`typescript
+import { createCheckoutSession } from './integrations/stripe/stripe.service';
+\`\`\`
+`;
+    }
+    if (config.integrations.mercadoPago) {
+      content += `
+### Mercado Pago
+Configurar \`MERCADOPAGO_ACCESS_TOKEN\` no .env
+\`\`\`typescript
+import { createPreference } from './integrations/mercado-pago/mercado-pago.service';
+\`\`\`
+`;
+    }
+    if (config.integrations.whatsapp) {
+      content += `
+### WhatsApp
+Configurar \`WHATSAPP_API_TOKEN\` e \`WHATSAPP_PHONE_ID\` no .env
+\`\`\`typescript
+import { sendMessage } from './integrations/whatsapp/whatsapp.service';
+await sendMessage('5511999999999', 'Ol\xE1!');
+\`\`\`
+`;
+    }
+  }
+  content += `
+## Variaveis de Ambiente
+
+Edite \`apps/api/.env\` com suas credenciais:
+
+| Variavel | Descricao |
+|----------|----------|
+| \`PORT\` | Porta da API (default: 3001) |
+`;
+  if (config.database === "postgresql" || config.database === "mysql") {
+    content += `| \`DATABASE_URL\` | URL de conexao do banco |
+`;
+  }
+  if (config.database === "mongodb") {
+    content += `| \`MONGODB_URI\` | URL de conexao do MongoDB |
+`;
+  }
+  if (config.auth.jwt) {
+    content += `| \`JWT_SECRET\` | **Alterar em producao!** Secret para tokens |
+`;
+  }
+  if (config.auth.googleOAuth) {
+    content += `| \`GOOGLE_CLIENT_ID\` | ID do app no Google Console |
+| \`GOOGLE_CLIENT_SECRET\` | Secret do app no Google Console |
+`;
+  }
+  if (config.redis) {
+    content += `| \`REDIS_HOST\` | Host do Redis (default: localhost) |
+`;
+  }
+  if (config.smtp) {
+    content += `| \`SMTP_HOST\`, \`SMTP_USER\`, \`SMTP_PASS\` | Credenciais SMTP |
+`;
+  }
+  if (config.minio) {
+    content += `| \`MINIO_ACCESS_KEY\`, \`MINIO_SECRET_KEY\` | Credenciais MinIO |
+`;
+  }
+  if (config.integrations.stripe) {
+    content += `| \`STRIPE_SECRET_KEY\` | Chave secreta do Stripe |
+`;
+  }
+  if (config.integrations.mercadoPago) {
+    content += `| \`MERCADOPAGO_ACCESS_TOKEN\` | Token do Mercado Pago |
+`;
+  }
+  content += `
+## Scripts
+
+| Comando | Descricao |
+|---------|----------|
+| \`${runCmd} dev\` | Inicia todos os apps |
+| \`${runCmd} build\` | Build de producao |
+| \`${runCmd} dev:api\` | Inicia apenas a API |
+| \`${runCmd} dev:web\` | Inicia apenas o frontend |
+${config.usePrisma ? `| \`cd apps/api && npx prisma studio\` | Admin visual do banco |
+| \`cd apps/api && npx prisma db push\` | Sync schema com banco |` : ""}
+${config.pm2 ? `| \`pm2 start ecosystem.config.cjs\` | Deploy com zero-downtime |` : ""}
+${hasDocker ? `| \`docker compose up -d\` | Subir infraestrutura |` : ""}
+
+## Liz - AI Agent
+
+Este projeto vem com a **Liz**, uma assistente de IA configurada para conhecer a arquitetura do projeto.
+
+- **Claude Code:** Liz carrega automaticamente via \`CLAUDE.md\`
+- **Cursor:** Regras em \`.cursor/rules/liz.mdc\`
+- **Outros:** Consulte \`AGENTS.md\` para contexto completo
+
+---
+
+Gerado com [PlazerCLI](https://github.com/pablocarss/plazercli)
+`;
+  await writeFile(path9.join(projectDir, "README.md"), content);
+}
+
+// src/generators/wiring.ts
+import path10 from "path";
+async function generateWiring(config, apiDir) {
+  switch (config.backend) {
+    case "nestjs":
+      await wireNestjs(config, apiDir);
+      break;
+    case "express":
+      await wireExpress(config, apiDir);
+      break;
+    case "fastify":
+      await wireFastify(config, apiDir);
+      break;
+  }
+}
+async function wireNestjs(config, apiDir) {
+  const imports = [];
+  const modules = [];
+  imports.push(`import { Module } from '@nestjs/common';`);
+  imports.push(`import { ConfigModule } from '@nestjs/config';`);
+  imports.push(`import { AppController } from './app.controller';`);
+  imports.push(`import { AppService } from './app.service';`);
+  modules.push(`ConfigModule.forRoot({ isGlobal: true })`);
+  if (config.usePrisma) {
+    imports.push(`import { PrismaModule } from './database/prisma.module';`);
+    modules.push("PrismaModule");
+  }
+  if (config.redis) {
+    imports.push(`import { RedisModule } from './infra/redis/redis.module';`);
+    modules.push("RedisModule");
+  }
+  if (config.smtp) {
+    imports.push(`import { EmailModule } from './infra/email/email.module';`);
+    modules.push("EmailModule");
+  }
+  if (config.minio) {
+    imports.push(`import { StorageModule } from './infra/storage/storage.module';`);
+    modules.push("StorageModule");
+  }
+  if (config.auth.jwt) {
+    imports.push(`import { AuthModule } from './auth/auth.module';`);
+    modules.push("AuthModule");
+  }
+  if (config.multiTenant) {
+    imports.push(`import { TenantModule } from './tenant/tenant.module';`);
+    modules.push("TenantModule");
+  }
+  if (config.queue === "bullmq") {
+    imports.push(`import { QueueModule } from './queue/queue.module';`);
+    modules.push("QueueModule");
+  }
+  if (config.queue === "rabbitmq") {
+    imports.push(`import { RabbitMQModule } from './queue/rabbitmq.config';`);
+    modules.push("RabbitMQModule");
+  }
+  const content = `${imports.join("\n")}
+
+@Module({
+  imports: [
+    ${modules.join(",\n    ")},
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+`;
+  await writeFile(path10.join(apiDir, "src", "app.module.ts"), content);
+}
+async function wireExpress(config, apiDir) {
+  const imports = [];
+  const setupLines = [];
+  const routeLines = [];
+  imports.push(`import express from 'express';`);
+  imports.push(`import cors from 'cors';`);
+  imports.push(`import helmet from 'helmet';`);
+  imports.push(`import { config } from './config/index.js';`);
+  imports.push(`import { router } from './routes/index.js';`);
+  imports.push(`import { errorHandler } from './middlewares/errorHandler.js';`);
+  if (config.useMongoose) {
+    imports.push(`import { connectDB } from './database/connection.js';`);
+    setupLines.push(`  // Conectar ao MongoDB`);
+    setupLines.push(`  await connectDB();`);
+  }
+  if (config.multiTenant) {
+    imports.push(`import { tenantMiddleware } from './tenant/tenant.middleware.js';`);
+  }
+  if (config.auth.jwt) {
+    imports.push(`import { authRouter } from './auth/auth.routes.js';`);
+  }
+  if (config.auth.magicLink) {
+    imports.push(`import { magicLinkRouter } from './auth/magic-link.routes.js';`);
+  }
+  if (config.auth.googleOAuth) {
+    imports.push(`import { googleRouter } from './auth/google.routes.js';`);
+  }
+  if (config.queue === "rabbitmq") {
+    imports.push(`import { connectRabbitMQ } from './queue/rabbitmq.js';`);
+    setupLines.push(`  // Conectar ao RabbitMQ`);
+    setupLines.push(`  await connectRabbitMQ();`);
+  }
+  if (config.minio) {
+    imports.push(`import { initStorage } from './infra/storage/storage.js';`);
+    setupLines.push(`  // Inicializar MinIO storage`);
+    setupLines.push(`  await initStorage();`);
+  }
+  if (config.multiTenant) {
+    routeLines.push(`app.use(tenantMiddleware);`);
+  }
+  if (config.auth.jwt) {
+    routeLines.push(`app.use('/api/auth', authRouter);`);
+  }
+  if (config.auth.magicLink) {
+    routeLines.push(`app.use('/api/auth/magic-link', magicLinkRouter);`);
+  }
+  if (config.auth.googleOAuth) {
+    routeLines.push(`app.use('/api/auth/google', googleRouter);`);
+  }
+  const appContent = `${imports.join("\n")}
+
+const app = express();
+
+app.use(helmet());
+app.use(cors({ origin: config.corsOrigin }));
+app.use(express.json());
+
+${routeLines.length > 0 ? "// Rotas auto-configuradas\n" + routeLines.join("\n") + "\n" : ""}
+app.use('/api', router);
+
+app.use(errorHandler);
+
+export { app };
+`;
+  const indexContent = `import { app } from './app.js';
+import { config } from './config/index.js';
+
+async function start() {
+${setupLines.length > 0 ? setupLines.join("\n") + "\n" : ""}
+  app.listen(config.port, () => {
+    console.log(\`\u{1F680} API rodando em http://localhost:\${config.port}\`);
+  });
+}
+
+start().catch((err) => {
+  console.error('Erro ao iniciar:', err);
+  process.exit(1);
+});
+`;
+  await writeFile(path10.join(apiDir, "src", "app.ts"), appContent);
+  await writeFile(path10.join(apiDir, "src", "index.ts"), indexContent);
+}
+async function wireFastify(config, apiDir) {
+  const imports = [];
+  const pluginLines = [];
+  const setupLines = [];
+  imports.push(`import Fastify from 'fastify';`);
+  imports.push(`import cors from '@fastify/cors';`);
+  imports.push(`import helmet from '@fastify/helmet';`);
+  imports.push(`import { config } from './config/index.js';`);
+  imports.push(`import { registerRoutes } from './routes/index.js';`);
+  if (config.useMongoose) {
+    imports.push(`import { connectDB } from './database/connection.js';`);
+    setupLines.push(`  await connectDB();`);
+  }
+  if (config.multiTenant) {
+    imports.push(`import tenantPlugin from './tenant/tenant.plugin.js';`);
+    pluginLines.push(`  await app.register(tenantPlugin);`);
+  }
+  if (config.auth.jwt) {
+    imports.push(`import { authRoutes } from './auth/auth.routes.js';`);
+    pluginLines.push(`  await app.register(authRoutes);`);
+  }
+  if (config.auth.magicLink) {
+    imports.push(`import { magicLinkRoutes } from './auth/magic-link.routes.js';`);
+    pluginLines.push(`  await app.register(magicLinkRoutes);`);
+  }
+  if (config.auth.googleOAuth) {
+    imports.push(`import { googleAuthRoutes } from './auth/google.routes.js';`);
+    pluginLines.push(`  await app.register(googleAuthRoutes);`);
+  }
+  if (config.queue === "rabbitmq") {
+    imports.push(`import { connectRabbitMQ } from './queue/rabbitmq.js';`);
+    setupLines.push(`  await connectRabbitMQ();`);
+  }
+  if (config.minio) {
+    imports.push(`import { initStorage } from './infra/storage/storage.js';`);
+    setupLines.push(`  await initStorage();`);
+  }
+  const appContent = `${imports.join("\n")}
+
+export async function buildApp() {
+  const app = Fastify({
+    logger: config.nodeEnv === 'development',
+  });
+
+  await app.register(helmet);
+  await app.register(cors, { origin: config.corsOrigin });
+
+${pluginLines.length > 0 ? "  // Plugins auto-configurados\n" + pluginLines.join("\n") + "\n" : ""}
+  registerRoutes(app);
+
+  return app;
+}
+`;
+  const indexContent = `import { buildApp } from './app.js';
+import { config } from './config/index.js';
+
+async function start() {
+${setupLines.length > 0 ? setupLines.join("\n") + "\n" : ""}
+  const app = await buildApp();
+
+  await app.listen({ port: config.port, host: config.host });
+  console.log(\`\u{1F680} API rodando em http://localhost:\${config.port}\`);
+}
+
+start().catch((err) => {
+  console.error('Erro ao iniciar:', err);
+  process.exit(1);
+});
+`;
+  await writeFile(path10.join(apiDir, "src", "app.ts"), appContent);
+  await writeFile(path10.join(apiDir, "src", "index.ts"), indexContent);
+}
+
+// src/generators/liz.ts
+import path11 from "path";
+async function generateLiz(config, projectDir) {
+  await generateAgentsMd(config, projectDir);
+  await generateCursorRules(config, projectDir);
+  await generateClaudeMd(config, projectDir);
+}
+async function generateAgentsMd(config, projectDir) {
+  const authMethods = [
+    config.auth.jwt && "JWT",
+    config.auth.magicLink && "Magic Link",
+    config.auth.googleOAuth && "Google OAuth"
+  ].filter(Boolean);
+  const integrations = [
+    config.integrations.viacep && "ViaCEP",
+    config.integrations.whatsapp && "WhatsApp",
+    config.integrations.stripe && "Stripe",
+    config.integrations.mercadoPago && "Mercado Pago",
+    config.integrations.abacatePay && "AbacatePay"
+  ].filter(Boolean);
+  const content = `# Liz - AI Development Agent
+
+## Identidade
+
+Eu sou a **Liz**, a assistente de desenvolvimento do projeto **${config.projectName}**. Fui configurada pelo PlazerCLI para conhecer profundamente a arquitetura deste projeto e ajudar no desenvolvimento.
+
+## Stack do Projeto
+
+- **Estrutura:** Monorepo com workspaces
+- **Frontend:** ${config.frontend} (apps/web/)
+- **Backend:** ${config.backend} (apps/api/)
+- **Runtime:** ${config.runtime}
+${config.database !== "none" ? `- **Banco de dados:** ${config.database} ${config.usePrisma ? "(Prisma ORM)" : "(Mongoose ODM)"}` : ""}
+${authMethods.length > 0 ? `- **Autentica\xE7\xE3o:** ${authMethods.join(", ")}` : ""}
+${config.redis ? "- **Cache:** Redis (ioredis)" : ""}
+${config.queue !== "none" ? `- **Filas:** ${config.queue}` : ""}
+${config.smtp ? "- **Email:** Nodemailer (SMTP)" : ""}
+${config.minio ? "- **Storage:** MinIO (S3-compatible)" : ""}
+${config.multiTenant ? "- **Multi-tenant:** Sim (isolamento por header/subdomain)" : ""}
+${config.pm2 ? "- **Deploy:** PM2 (cluster mode, zero-downtime)" : ""}
+${integrations.length > 0 ? `- **Integra\xE7\xF5es:** ${integrations.join(", ")}` : ""}
+
+## Estrutura de Diret\xF3rios
+
+\`\`\`
+${config.projectName}/
+\u251C\u2500\u2500 apps/
+\u2502   \u251C\u2500\u2500 api/                    # Backend (${config.backend})
+\u2502   \u2502   \u251C\u2500\u2500 src/
+${config.usePrisma ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 database/        # Prisma service e conex\xE3o\n" : ""}${config.useMongoose ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 database/        # Mongoose models e conex\xE3o\n" : ""}${config.hasAnyAuth ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 auth/            # Autentica\xE7\xE3o e guards\n" : ""}${config.redis ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 infra/redis/     # Redis service\n" : ""}${config.smtp ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 infra/email/     # Email service e templates\n" : ""}${config.minio ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 infra/storage/   # MinIO storage service\n" : ""}${config.hasAnyQueue ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 queue/           # Workers e processadores\n" : ""}${config.hasAnyIntegration ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 integrations/    # Integra\xE7\xF5es externas\n" : ""}${config.multiTenant ? "\u2502   \u2502   \u2502   \u251C\u2500\u2500 tenant/          # Multi-tenant middleware\n" : ""}\u2502   \u2502   \u2502   \u251C\u2500\u2500 routes/          # Rotas da API
+\u2502   \u2502   \u2502   \u251C\u2500\u2500 config/          # Configura\xE7\xF5es
+\u2502   \u2502   \u2502   \u2514\u2500\u2500 middlewares/     # Middlewares
+${config.usePrisma ? "\u2502   \u2502   \u2514\u2500\u2500 prisma/              # Schema do banco\n" : ""}\u2502   \u2502   \u2514\u2500\u2500 .env                # Vari\xE1veis de ambiente
+\u2502   \u2514\u2500\u2500 web/                    # Frontend (${config.frontend})
+\u2502       \u2514\u2500\u2500 src/
+\u251C\u2500\u2500 docker-compose.yml
+\u251C\u2500\u2500 .env.example
+\u2514\u2500\u2500 README.md
+\`\`\`
+
+## Conven\xE7\xF5es
+
+### C\xF3digo
+- TypeScript strict mode
+- ESM modules (import/export)
+- Async/await para opera\xE7\xF5es ass\xEDncronas
+- Nomes em ingl\xEAs para c\xF3digo, coment\xE1rios podem ser em portugu\xEAs
+
+### API
+- Prefixo \`/api\` em todas as rotas
+- Health check em \`GET /api/health\`
+${config.hasAnyAuth ? `- Rotas de auth em \`/api/auth/*\`` : ""}
+- Respostas JSON com status HTTP corretos
+
+### Banco de Dados
+${config.usePrisma ? `- Prisma como ORM
+- Schema em \`apps/api/prisma/schema.prisma\`
+- Rodar \`npx prisma db push\` ap\xF3s alterar schema
+- Rodar \`npx prisma generate\` ap\xF3s alterar models` : ""}
+${config.useMongoose ? `- Mongoose como ODM
+- Models em \`apps/api/src/database/models/\`
+- Conex\xE3o em \`apps/api/src/database/connection.ts\`` : ""}
+
+## Como me usar
+
+Ao desenvolver, me pe\xE7a para:
+- Criar novas features seguindo a arquitetura existente
+- Criar novos endpoints/rotas
+- Adicionar models ao banco de dados
+- Criar novos workers/jobs
+- Integrar novos servi\xE7os
+- Debugar erros com contexto do projeto
+- Escrever testes
+
+Eu conhe\xE7o toda a stack e vou seguir as conven\xE7\xF5es do projeto.
+
+---
+*Configurada por PlazerCLI - https://github.com/pablocarss/plazercli*
+`;
+  await writeFile(path11.join(projectDir, "AGENTS.md"), content);
+}
+async function generateCursorRules(config, projectDir) {
+  await ensureDir(path11.join(projectDir, ".cursor", "rules"));
+  const content = `# Liz - PlazerCLI AI Agent Rules
+
+You are Liz, the AI development assistant for the "${config.projectName}" project.
+
+## Project Context
+- Monorepo with apps/api (${config.backend}) and apps/web (${config.frontend})
+- Runtime: ${config.runtime}
+${config.database !== "none" ? `- Database: ${config.database} ${config.usePrisma ? "with Prisma ORM" : "with Mongoose ODM"}` : ""}
+${config.hasAnyAuth ? "- Authentication configured and wired" : ""}
+${config.redis ? "- Redis for caching" : ""}
+${config.queue !== "none" ? `- Queue system: ${config.queue}` : ""}
+
+## Rules
+- Always use TypeScript with strict mode
+- Follow existing patterns in the codebase
+- Use ESM imports (import/export, .js extensions)
+- API routes must be prefixed with /api
+- Use the existing database service/ORM for all DB operations
+${config.usePrisma ? "- After schema changes, remind to run: npx prisma db push" : ""}
+${config.backend === "nestjs" ? "- Follow NestJS patterns: modules, controllers, services, guards" : ""}
+${config.backend === "express" ? "- Use Express Router for new route groups" : ""}
+${config.backend === "fastify" ? "- Use Fastify plugins for new functionality" : ""}
+- Write clean, minimal code - no over-engineering
+- Handle errors properly with appropriate HTTP status codes
+`;
+  await writeFile(path11.join(projectDir, ".cursor", "rules", "liz.mdc"), content);
+}
+async function generateClaudeMd(config, projectDir) {
+  const content = `# CLAUDE.md - Liz Agent Configuration
+
+You are **Liz**, the AI development assistant for **${config.projectName}**.
+
+## Project Overview
+This is a fullstack monorepo generated by PlazerCLI.
+
+- \`apps/api/\` - Backend (${config.backend})
+- \`apps/web/\` - Frontend (${config.frontend})
+- Runtime: ${config.runtime}
+${config.database !== "none" ? `- Database: ${config.database}` : ""}
+
+## Key Files
+${config.backend === "nestjs" ? "- `apps/api/src/app.module.ts` - Main module (all features auto-imported)" : ""}
+${config.backend === "express" ? "- `apps/api/src/app.ts` - Express app (all routes auto-registered)" : ""}
+${config.backend === "fastify" ? "- `apps/api/src/app.ts` - Fastify app (all plugins auto-registered)" : ""}
+${config.usePrisma ? "- `apps/api/prisma/schema.prisma` - Database schema" : ""}
+- \`apps/api/.env\` - Environment variables
+- \`docker-compose.yml\` - Infrastructure services
+
+## Commands
+- \`${config.runtime} run dev\` - Start all apps
+- \`${config.runtime} run dev:api\` - Start only API
+- \`${config.runtime} run dev:web\` - Start only frontend
+${config.usePrisma ? "- `cd apps/api && npx prisma db push` - Push schema to DB\n- `cd apps/api && npx prisma studio` - Open DB admin" : ""}
+- \`docker compose up -d\` - Start infrastructure
+
+## Conventions
+- TypeScript strict, ESM modules
+- API prefix: /api
+- Follow existing patterns when creating new features
+`;
+  await writeFile(path11.join(projectDir, "CLAUDE.md"), content);
+}
+
+// src/installers/database/prisma.ts
+import path12 from "path";
+var prismaInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies, devDependencies, scripts } = opts;
+  const provider = config.database === "postgresql" ? "postgresql" : "mysql";
+  const dbName = config.projectName.replace(/-/g, "_");
+  await ensureDir(path12.join(apiDir, "prisma"));
+  await ensureDir(path12.join(apiDir, "src", "database"));
+  let schema = `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  password  String?
+  createdAt DateTime @default(now()) @map("created_at")
+  updatedAt DateTime @updatedAt @map("updated_at")
+`;
+  if (config.multiTenant) {
+    schema += `  tenantId  String   @map("tenant_id")
+  tenant    Tenant   @relation(fields: [tenantId], references: [id])
+`;
+  }
+  schema += `
+  @@map("users")
+}
+`;
+  if (config.multiTenant) {
+    schema += `
+model Tenant {
+  id        String   @id @default(cuid())
+  name      String
+  slug      String   @unique
+  users     User[]
+  createdAt DateTime @default(now()) @map("created_at")
+  updatedAt DateTime @updatedAt @map("updated_at")
+
+  @@map("tenants")
+}
+`;
+  }
+  await writeFile(path12.join(apiDir, "prisma", "schema.prisma"), schema);
+  if (config.backend === "nestjs") {
+    await writeFile(path12.join(apiDir, "src", "database", "prisma.service.ts"), `import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+}
+`);
+    await writeFile(path12.join(apiDir, "src", "database", "prisma.module.ts"), `import { Global, Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}
+`);
+  } else {
+    await writeFile(path12.join(apiDir, "src", "database", "prisma.ts"), `import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
+
+export const prisma = globalForPrisma.prisma || new PrismaClient();
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
+
+export default prisma;
+`);
+  }
+  dependencies["@prisma/client"] = dependencyVersionMap["@prisma/client"];
+  devDependencies["prisma"] = dependencyVersionMap.prisma;
+  scripts["db:push"] = "prisma db push";
+  scripts["db:migrate"] = "prisma migrate dev";
+  scripts["db:studio"] = "prisma studio";
+  scripts["db:seed"] = "prisma db seed";
+  scripts["db:generate"] = "prisma generate";
+};
+
+// src/installers/database/mongoose.ts
+import path13 from "path";
+var mongooseInstaller = async (opts) => {
+  const { config, apiDir, dependencies } = opts;
+  await ensureDir(path13.join(apiDir, "src", "database"));
+  await ensureDir(path13.join(apiDir, "src", "database", "models"));
+  if (config.multiTenant) {
+    await writeFile(path13.join(apiDir, "src", "database", "connection.ts"), `import mongoose from 'mongoose';
+
+const connections = new Map<string, mongoose.Connection>();
+
+export async function connectDB(): Promise<mongoose.Connection> {
+  const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017/${config.projectName.replace(/-/g, "_")}';
+  const conn = await mongoose.connect(uri);
+  console.log('MongoDB conectado');
+  return conn.connection;
+}
+
+export function getTenantConnection(tenantId: string): mongoose.Connection {
+  if (connections.has(tenantId)) {
+    return connections.get(tenantId)!;
+  }
+
+  const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017';
+  const conn = mongoose.createConnection(\`\${uri}/tenant_\${tenantId}\`);
+  connections.set(tenantId, conn);
+  return conn;
+}
+
+export default { connectDB, getTenantConnection };
+`);
+  } else {
+    await writeFile(path13.join(apiDir, "src", "database", "connection.ts"), `import mongoose from 'mongoose';
+
+export async function connectDB(): Promise<void> {
+  const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017/${config.projectName.replace(/-/g, "_")}';
+  await mongoose.connect(uri);
+  console.log('MongoDB conectado');
+}
+
+export default { connectDB };
+`);
+  }
+  await writeFile(path13.join(apiDir, "src", "database", "models", "user.model.ts"), `import mongoose, { Schema, Document } from 'mongoose';
+
+export interface IUser extends Document {
+  email: string;
+  name?: string;
+  password?: string;
+${config.multiTenant ? "  tenantId: string;\n" : ""}  createdAt: Date;
+  updatedAt: Date;
+}
+
+const UserSchema = new Schema<IUser>(
+  {
+    email: { type: String, required: true, unique: true },
+    name: { type: String },
+    password: { type: String },
+${config.multiTenant ? "    tenantId: { type: String, required: true, index: true },\n" : ""}  },
+  { timestamps: true }
+);
+
+export const User = mongoose.model<IUser>('User', UserSchema);
+`);
+  dependencies["mongoose"] = dependencyVersionMap.mongoose;
+};
+
+// src/installers/auth/jwt.ts
+import path14 from "path";
+var jwtInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies, devDependencies } = opts;
+  await ensureDir(path14.join(apiDir, "src", "auth"));
+  envEntries.push(
+    { key: "JWT_SECRET", value: "change-me-in-production-use-a-strong-secret", category: "Authentication" },
+    { key: "JWT_EXPIRES_IN", value: "7d", category: "Authentication" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path14.join(apiDir, "src", "auth", "jwt.strategy.ts"), `import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(configService: ConfigService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get<string>('JWT_SECRET'),
+    });
+  }
+
+  async validate(payload: { sub: string; email: string }) {
+    return { id: payload.sub, email: payload.email };
+  }
+}
+`);
+    await writeFile(path14.join(apiDir, "src", "auth", "auth.module.ts"), `import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { AuthService } from './auth.service';
+import { AuthController } from './auth.controller';
+import { JwtStrategy } from './jwt.strategy';
+
+@Module({
+  imports: [
+    PassportModule,
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: (configService: ConfigService) => ({
+        secret: configService.get<string>('JWT_SECRET'),
+        signOptions: { expiresIn: configService.get<string>('JWT_EXPIRES_IN', '7d') },
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+  controllers: [AuthController],
+  providers: [AuthService, JwtStrategy],
+  exports: [AuthService],
+})
+export class AuthModule {}
+`);
+    await writeFile(path14.join(apiDir, "src", "auth", "auth.service.ts"), `import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import * as bcrypt from 'bcryptjs';
+
+@Injectable()
+export class AuthService {
+  constructor(private jwtService: JwtService) {}
+
+  async hashPassword(password: string): Promise<string> {
+    return bcrypt.hash(password, 10);
+  }
+
+  async comparePassword(password: string, hash: string): Promise<boolean> {
+    return bcrypt.compare(password, hash);
+  }
+
+  async generateToken(payload: { sub: string; email: string }): Promise<string> {
+    return this.jwtService.sign(payload);
+  }
+
+  async validateToken(token: string) {
+    try {
+      return this.jwtService.verify(token);
+    } catch {
+      throw new UnauthorizedException('Token inv\xE1lido');
+    }
+  }
+}
+`);
+    await writeFile(path14.join(apiDir, "src", "auth", "auth.controller.ts"), `import { Controller, Post, Body } from '@nestjs/common';
+import { AuthService } from './auth.service';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('login')
+  async login(@Body() body: { email: string; password: string }) {
+    // TODO: Buscar usuario no banco e validar password
+    const token = await this.authService.generateToken({
+      sub: 'user-id',
+      email: body.email,
+    });
+    return { access_token: token };
+  }
+
+  @Post('register')
+  async register(@Body() body: { email: string; password: string; name?: string }) {
+    const hashedPassword = await this.authService.hashPassword(body.password);
+    // TODO: Criar usuario no banco com hashedPassword
+    const token = await this.authService.generateToken({
+      sub: 'new-user-id',
+      email: body.email,
+    });
+    return { access_token: token };
+  }
+}
+`);
+    await writeFile(path14.join(apiDir, "src", "auth", "jwt-auth.guard.ts"), `import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {}
+`);
+    dependencies["@nestjs/jwt"] = dependencyVersionMap["@nestjs/jwt"];
+    dependencies["@nestjs/passport"] = dependencyVersionMap["@nestjs/passport"];
+    dependencies["passport"] = dependencyVersionMap.passport;
+    dependencies["passport-jwt"] = dependencyVersionMap["passport-jwt"];
+    devDependencies["@types/passport-jwt"] = dependencyVersionMap["@types/passport-jwt"];
+  } else {
+    await writeFile(path14.join(apiDir, "src", "auth", "jwt.ts"), `import jwt from 'jsonwebtoken';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'change-me';
+const JWT_EXPIRES_IN = process.env.JWT_EXPIRES_IN || '7d';
+
+export function generateToken(payload: { sub: string; email: string }): string {
+  return jwt.sign(payload, JWT_SECRET, { expiresIn: JWT_EXPIRES_IN });
+}
+
+export function verifyToken(token: string) {
+  return jwt.verify(token, JWT_SECRET);
+}
+`);
+    await writeFile(path14.join(apiDir, "src", "auth", "hash.ts"), `import bcrypt from 'bcryptjs';
+
+export async function hashPassword(password: string): Promise<string> {
+  return bcrypt.hash(password, 10);
+}
+
+export async function comparePassword(password: string, hash: string): Promise<boolean> {
+  return bcrypt.compare(password, hash);
+}
+`);
+    if (config.backend === "express") {
+      await writeFile(path14.join(apiDir, "src", "auth", "auth.middleware.ts"), `import type { Request, Response, NextFunction } from 'express';
+import { verifyToken } from './jwt.js';
+
+export function authMiddleware(req: Request, res: Response, next: NextFunction) {
+  const authHeader = req.headers.authorization;
+  if (!authHeader?.startsWith('Bearer ')) {
+    return res.status(401).json({ error: 'Token n\xE3o fornecido' });
+  }
+
+  try {
+    const token = authHeader.split(' ')[1];
+    const payload = verifyToken(token);
+    (req as any).user = payload;
+    next();
+  } catch {
+    return res.status(401).json({ error: 'Token inv\xE1lido' });
+  }
+}
+`);
+      await writeFile(path14.join(apiDir, "src", "auth", "auth.routes.ts"), `import { Router } from 'express';
+import { generateToken } from './jwt.js';
+import { hashPassword, comparePassword } from './hash.js';
+
+const authRouter = Router();
+
+authRouter.post('/login', async (req, res) => {
+  const { email, password } = req.body;
+  // TODO: Buscar usuario no banco e validar password
+  const token = generateToken({ sub: 'user-id', email });
+  res.json({ access_token: token });
+});
+
+authRouter.post('/register', async (req, res) => {
+  const { email, password, name } = req.body;
+  const hashedPassword = await hashPassword(password);
+  // TODO: Criar usuario no banco com hashedPassword
+  const token = generateToken({ sub: 'new-user-id', email });
+  res.json({ access_token: token });
+});
+
+export { authRouter };
+`);
+    } else {
+      await writeFile(path14.join(apiDir, "src", "auth", "auth.hook.ts"), `import type { FastifyRequest, FastifyReply } from 'fastify';
+import { verifyToken } from './jwt.js';
+
+export async function authHook(request: FastifyRequest, reply: FastifyReply) {
+  const authHeader = request.headers.authorization;
+  if (!authHeader?.startsWith('Bearer ')) {
+    return reply.status(401).send({ error: 'Token n\xE3o fornecido' });
+  }
+
+  try {
+    const token = authHeader.split(' ')[1];
+    const payload = verifyToken(token);
+    (request as any).user = payload;
+  } catch {
+    return reply.status(401).send({ error: 'Token inv\xE1lido' });
+  }
+}
+`);
+      await writeFile(path14.join(apiDir, "src", "auth", "auth.routes.ts"), `import type { FastifyInstance } from 'fastify';
+import { generateToken } from './jwt.js';
+import { hashPassword } from './hash.js';
+
+export async function authRoutes(app: FastifyInstance) {
+  app.post('/api/auth/login', async (request) => {
+    const { email, password } = request.body as { email: string; password: string };
+    // TODO: Buscar usuario no banco e validar password
+    const token = generateToken({ sub: 'user-id', email });
+    return { access_token: token };
+  });
+
+  app.post('/api/auth/register', async (request) => {
+    const { email, password, name } = request.body as { email: string; password: string; name?: string };
+    const hashedPassword = await hashPassword(password);
+    // TODO: Criar usuario no banco com hashedPassword
+    const token = generateToken({ sub: 'new-user-id', email });
+    return { access_token: token };
+  });
+}
+`);
+    }
+    dependencies["jsonwebtoken"] = dependencyVersionMap.jsonwebtoken;
+    devDependencies["@types/jsonwebtoken"] = dependencyVersionMap["@types/jsonwebtoken"];
+  }
+  dependencies["bcryptjs"] = dependencyVersionMap.bcryptjs;
+  devDependencies["@types/bcryptjs"] = dependencyVersionMap["@types/bcryptjs"];
+};
+
+// src/installers/auth/magicLink.ts
+import path15 from "path";
+var magicLinkInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies } = opts;
+  await ensureDir(path15.join(apiDir, "src", "auth"));
+  envEntries.push(
+    { key: "MAGIC_LINK_EXPIRY_MINUTES", value: "15", category: "Authentication" },
+    { key: "APP_URL", value: "http://localhost:3000", category: "Authentication", comment: "URL do frontend para o magic link" }
+  );
+  const serviceContent = `import { nanoid } from 'nanoid';
+
+interface MagicLinkToken {
+  token: string;
+  email: string;
+  expiresAt: Date;
+}
+
+// Em producao, armazene no banco de dados ou Redis
+const tokens = new Map<string, MagicLinkToken>();
+
+const EXPIRY_MINUTES = Number(process.env.MAGIC_LINK_EXPIRY_MINUTES) || 15;
+const APP_URL = process.env.APP_URL || 'http://localhost:3000';
+
+export function generateMagicLink(email: string): { token: string; url: string } {
+  const token = nanoid(32);
+  const expiresAt = new Date(Date.now() + EXPIRY_MINUTES * 60 * 1000);
+
+  tokens.set(token, { token, email, expiresAt });
+
+  const url = \`\${APP_URL}/auth/verify?token=\${token}\`;
+  return { token, url };
+}
+
+export function verifyMagicLinkToken(token: string): { valid: boolean; email?: string } {
+  const entry = tokens.get(token);
+  if (!entry) return { valid: false };
+  if (entry.expiresAt < new Date()) {
+    tokens.delete(token);
+    return { valid: false };
+  }
+  tokens.delete(token);
+  return { valid: true, email: entry.email };
+}
+`;
+  await writeFile(path15.join(apiDir, "src", "auth", "magic-link.service.ts"), serviceContent);
+  if (config.backend === "nestjs") {
+    await writeFile(path15.join(apiDir, "src", "auth", "magic-link.controller.ts"), `import { Controller, Post, Body, Get, Query, BadRequestException } from '@nestjs/common';
+import { generateMagicLink, verifyMagicLinkToken } from './magic-link.service';
+
+@Controller('auth/magic-link')
+export class MagicLinkController {
+  @Post('send')
+  async sendMagicLink(@Body() body: { email: string }) {
+    const { url } = generateMagicLink(body.email);
+    // TODO: Enviar email com o magic link usando o email service
+    console.log('Magic link:', url);
+    return { message: 'Magic link enviado para o email' };
+  }
+
+  @Get('verify')
+  async verify(@Query('token') token: string) {
+    const result = verifyMagicLinkToken(token);
+    if (!result.valid) {
+      throw new BadRequestException('Token inv\xE1lido ou expirado');
+    }
+    // TODO: Criar sessao/JWT para o usuario
+    return { message: 'Login realizado', email: result.email };
+  }
+}
+`);
+  } else if (config.backend === "express") {
+    await writeFile(path15.join(apiDir, "src", "auth", "magic-link.routes.ts"), `import { Router } from 'express';
+import { generateMagicLink, verifyMagicLinkToken } from './magic-link.service.js';
+
+const magicLinkRouter = Router();
+
+magicLinkRouter.post('/send', async (req, res) => {
+  const { email } = req.body;
+  const { url } = generateMagicLink(email);
+  // TODO: Enviar email com o magic link usando o email service
+  console.log('Magic link:', url);
+  res.json({ message: 'Magic link enviado para o email' });
+});
+
+magicLinkRouter.get('/verify', async (req, res) => {
+  const token = req.query.token as string;
+  const result = verifyMagicLinkToken(token);
+  if (!result.valid) {
+    return res.status(400).json({ error: 'Token inv\xE1lido ou expirado' });
+  }
+  // TODO: Criar sessao/JWT para o usuario
+  res.json({ message: 'Login realizado', email: result.email });
+});
+
+export { magicLinkRouter };
+`);
+  } else {
+    await writeFile(path15.join(apiDir, "src", "auth", "magic-link.routes.ts"), `import type { FastifyInstance } from 'fastify';
+import { generateMagicLink, verifyMagicLinkToken } from './magic-link.service.js';
+
+export async function magicLinkRoutes(app: FastifyInstance) {
+  app.post('/api/auth/magic-link/send', async (request) => {
+    const { email } = request.body as { email: string };
+    const { url } = generateMagicLink(email);
+    // TODO: Enviar email com o magic link usando o email service
+    console.log('Magic link:', url);
+    return { message: 'Magic link enviado para o email' };
+  });
+
+  app.get('/api/auth/magic-link/verify', async (request, reply) => {
+    const { token } = request.query as { token: string };
+    const result = verifyMagicLinkToken(token);
+    if (!result.valid) {
+      return reply.status(400).send({ error: 'Token inv\xE1lido ou expirado' });
+    }
+    // TODO: Criar sessao/JWT para o usuario
+    return { message: 'Login realizado', email: result.email };
+  });
+}
+`);
+  }
+  dependencies["nanoid"] = dependencyVersionMap.nanoid;
+};
+
+// src/installers/auth/googleOauth.ts
+import path16 from "path";
+var googleOauthInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies, devDependencies } = opts;
+  await ensureDir(path16.join(apiDir, "src", "auth"));
+  envEntries.push(
+    { key: "GOOGLE_CLIENT_ID", value: "", category: "Google OAuth", comment: "Obtenha em https://console.cloud.google.com" },
+    { key: "GOOGLE_CLIENT_SECRET", value: "", category: "Google OAuth" },
+    { key: "GOOGLE_CALLBACK_URL", value: "http://localhost:3001/api/auth/google/callback", category: "Google OAuth" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path16.join(apiDir, "src", "auth", "google.strategy.ts"), `import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { Strategy, VerifyCallback, Profile } from 'passport-google-oauth20';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
+  constructor(configService: ConfigService) {
+    super({
+      clientID: configService.get<string>('GOOGLE_CLIENT_ID'),
+      clientSecret: configService.get<string>('GOOGLE_CLIENT_SECRET'),
+      callbackURL: configService.get<string>('GOOGLE_CALLBACK_URL'),
+      scope: ['email', 'profile'],
+    });
+  }
+
+  async validate(
+    accessToken: string,
+    refreshToken: string,
+    profile: Profile,
+    done: VerifyCallback,
+  ) {
+    const user = {
+      email: profile.emails?.[0]?.value,
+      name: profile.displayName,
+      googleId: profile.id,
+      avatar: profile.photos?.[0]?.value,
+    };
+    done(null, user);
+  }
+}
+`);
+    await writeFile(path16.join(apiDir, "src", "auth", "google.controller.ts"), `import { Controller, Get, Req, Res, UseGuards } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import type { Request, Response } from 'express';
+
+@Controller('auth/google')
+export class GoogleController {
+  @Get()
+  @UseGuards(AuthGuard('google'))
+  async googleAuth() {
+    // Redireciona para o Google
+  }
+
+  @Get('callback')
+  @UseGuards(AuthGuard('google'))
+  async googleCallback(@Req() req: Request, @Res() res: Response) {
+    const user = req.user;
+    // TODO: Criar/buscar usuario no banco, gerar JWT
+    console.log('Google user:', user);
+    res.redirect(process.env.APP_URL || 'http://localhost:3000');
+  }
+}
+`);
+    dependencies["@nestjs/passport"] = dependencyVersionMap["@nestjs/passport"];
+    dependencies["passport"] = dependencyVersionMap.passport;
+  } else if (config.backend === "express") {
+    await writeFile(path16.join(apiDir, "src", "auth", "google.routes.ts"), `import { Router } from 'express';
+import passport from 'passport';
+import { Strategy as GoogleStrategy } from 'passport-google-oauth20';
+
+passport.use(
+  new GoogleStrategy(
+    {
+      clientID: process.env.GOOGLE_CLIENT_ID || '',
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET || '',
+      callbackURL: process.env.GOOGLE_CALLBACK_URL || 'http://localhost:3001/api/auth/google/callback',
+    },
+    async (accessToken, refreshToken, profile, done) => {
+      const user = {
+        email: profile.emails?.[0]?.value,
+        name: profile.displayName,
+        googleId: profile.id,
+        avatar: profile.photos?.[0]?.value,
+      };
+      // TODO: Criar/buscar usuario no banco
+      done(null, user);
+    }
+  )
+);
+
+const googleRouter = Router();
+
+googleRouter.get('/', passport.authenticate('google', { scope: ['profile', 'email'] }));
+
+googleRouter.get(
+  '/callback',
+  passport.authenticate('google', { session: false }),
+  (req, res) => {
+    // TODO: Gerar JWT e redirecionar
+    console.log('Google user:', req.user);
+    res.redirect(process.env.APP_URL || 'http://localhost:3000');
+  }
+);
+
+export { googleRouter };
+`);
+    dependencies["passport"] = dependencyVersionMap.passport;
+  } else {
+    await writeFile(path16.join(apiDir, "src", "auth", "google.routes.ts"), `import type { FastifyInstance } from 'fastify';
+
+// Para Fastify, recomendamos usar @fastify/oauth2
+// npm install @fastify/oauth2
+export async function googleAuthRoutes(app: FastifyInstance) {
+  // TODO: Configurar @fastify/oauth2 para Google
+  // Documentacao: https://github.com/fastify/fastify-oauth2
+
+  app.get('/api/auth/google', async (request, reply) => {
+    const clientId = process.env.GOOGLE_CLIENT_ID;
+    const redirectUri = process.env.GOOGLE_CALLBACK_URL;
+    const url = \`https://accounts.google.com/o/oauth2/v2/auth?client_id=\${clientId}&redirect_uri=\${redirectUri}&response_type=code&scope=email profile\`;
+    reply.redirect(url);
+  });
+
+  app.get('/api/auth/google/callback', async (request) => {
+    const { code } = request.query as { code: string };
+    // TODO: Trocar code por tokens, buscar perfil, criar/buscar usuario
+    return { message: 'Google OAuth callback', code };
+  });
+}
+`);
+  }
+  dependencies["passport-google-oauth20"] = dependencyVersionMap["passport-google-oauth20"];
+  devDependencies["@types/passport-google-oauth20"] = dependencyVersionMap["@types/passport-google-oauth20"];
+};
+
+// src/installers/queue/bullmq.ts
+import path17 from "path";
+var bullmqInstaller = async (opts) => {
+  const { config, apiDir, dependencies } = opts;
+  await ensureDir(path17.join(apiDir, "src", "queue"));
+  if (config.backend === "nestjs") {
+    await writeFile(path17.join(apiDir, "src", "queue", "queue.module.ts"), `import { Module } from '@nestjs/common';
+import { BullModule } from '@nestjs/bullmq';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { ExampleProcessor } from './example.processor';
+
+@Module({
+  imports: [
+    BullModule.forRootAsync({
+      imports: [ConfigModule],
+      useFactory: (configService: ConfigService) => ({
+        connection: {
+          host: configService.get('REDIS_HOST', 'localhost'),
+          port: configService.get('REDIS_PORT', 6379),
+          password: configService.get('REDIS_PASSWORD') || undefined,
+        },
+      }),
+      inject: [ConfigService],
+    }),
+    BullModule.registerQueue({ name: 'example' }),
+  ],
+  providers: [ExampleProcessor],
+  exports: [BullModule],
+})
+export class QueueModule {}
+`);
+    await writeFile(path17.join(apiDir, "src", "queue", "example.processor.ts"), `import { Processor, WorkerHost } from '@nestjs/bullmq';
+import { Job } from 'bullmq';
+
+@Processor('example')
+export class ExampleProcessor extends WorkerHost {
+  async process(job: Job<{ message: string }>) {
+    console.log(\`Processando job \${job.id}: \${job.data.message}\`);
+    // TODO: Implemente a logica do job aqui
+    return { success: true };
+  }
+}
+`);
+    dependencies["@nestjs/bullmq"] = dependencyVersionMap["@nestjs/bullmq"];
+  } else {
+    await writeFile(path17.join(apiDir, "src", "queue", "queue.config.ts"), `import { Queue, Worker } from 'bullmq';
+
+const connection = {
+  host: process.env.REDIS_HOST || 'localhost',
+  port: Number(process.env.REDIS_PORT) || 6379,
+  password: process.env.REDIS_PASSWORD || undefined,
+};
+
+export function createQueue(name: string) {
+  return new Queue(name, { connection });
+}
+
+export function createWorker(
+  name: string,
+  processor: (job: any) => Promise<any>
+) {
+  const worker = new Worker(name, processor, { connection });
+
+  worker.on('completed', (job) => {
+    console.log(\`Job \${job.id} concluido\`);
+  });
+
+  worker.on('failed', (job, err) => {
+    console.error(\`Job \${job?.id} falhou:\`, err);
+  });
+
+  return worker;
+}
+`);
+    await writeFile(path17.join(apiDir, "src", "queue", "example.worker.ts"), `import { createQueue, createWorker } from './queue.config.js';
+
+// Criar fila
+export const exampleQueue = createQueue('example');
+
+// Criar worker
+export const exampleWorker = createWorker('example', async (job) => {
+  console.log(\`Processando job \${job.id}: \${job.data.message}\`);
+  // TODO: Implemente a logica do job aqui
+  return { success: true };
+});
+
+// Funcao helper para adicionar job na fila
+export async function addExampleJob(data: { message: string }) {
+  return exampleQueue.add('process', data);
+}
+`);
+  }
+  dependencies["bullmq"] = dependencyVersionMap.bullmq;
+};
+
+// src/installers/queue/rabbitmq.ts
+import path18 from "path";
+var rabbitmqInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies, devDependencies } = opts;
+  await ensureDir(path18.join(apiDir, "src", "queue"));
+  envEntries.push(
+    { key: "RABBITMQ_URL", value: "amqp://guest:guest@localhost:5672", category: "RabbitMQ" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path18.join(apiDir, "src", "queue", "rabbitmq.config.ts"), `import { Module } from '@nestjs/common';
+import { ClientsModule, Transport } from '@nestjs/microservices';
+
+@Module({
+  imports: [
+    ClientsModule.register([
+      {
+        name: 'RABBITMQ_SERVICE',
+        transport: Transport.RMQ,
+        options: {
+          urls: [process.env.RABBITMQ_URL || 'amqp://guest:guest@localhost:5672'],
+          queue: 'main_queue',
+          queueOptions: { durable: true },
+        },
+      },
+    ]),
+  ],
+  exports: [ClientsModule],
+})
+export class RabbitMQModule {}
+`);
+    await writeFile(path18.join(apiDir, "src", "queue", "rabbitmq.consumer.ts"), `import { Controller } from '@nestjs/common';
+import { MessagePattern, Payload } from '@nestjs/microservices';
+
+@Controller()
+export class RabbitMQConsumer {
+  @MessagePattern('example_pattern')
+  async handleMessage(@Payload() data: any) {
+    console.log('Mensagem recebida:', data);
+    // TODO: Processar mensagem
+    return { success: true };
+  }
+}
+`);
+    dependencies["@nestjs/microservices"] = dependencyVersionMap["@nestjs/common"];
+  } else {
+    await writeFile(path18.join(apiDir, "src", "queue", "rabbitmq.ts"), `import amqplib, { type Channel, type Connection } from 'amqplib';
+
+let connection: Connection | null = null;
+let channel: Channel | null = null;
+
+export async function connectRabbitMQ(): Promise<Channel> {
+  const url = process.env.RABBITMQ_URL || 'amqp://guest:guest@localhost:5672';
+  connection = await amqplib.connect(url);
+  channel = await connection.createChannel();
+  console.log('RabbitMQ conectado');
+  return channel;
+}
+
+export async function publishMessage(queue: string, message: unknown): Promise<void> {
+  if (!channel) throw new Error('RabbitMQ nao conectado');
+  await channel.assertQueue(queue, { durable: true });
+  channel.sendToQueue(queue, Buffer.from(JSON.stringify(message)), { persistent: true });
+}
+
+export async function consumeMessages(
+  queue: string,
+  handler: (msg: unknown) => Promise<void>
+): Promise<void> {
+  if (!channel) throw new Error('RabbitMQ nao conectado');
+  await channel.assertQueue(queue, { durable: true });
+  channel.consume(queue, async (msg) => {
+    if (!msg) return;
+    try {
+      const data = JSON.parse(msg.content.toString());
+      await handler(data);
+      channel!.ack(msg);
+    } catch (err) {
+      console.error('Erro ao processar mensagem:', err);
+      channel!.nack(msg, false, true);
+    }
+  });
+}
+
+export async function closeRabbitMQ(): Promise<void> {
+  await channel?.close();
+  await connection?.close();
+}
+`);
+  }
+  dependencies["amqplib"] = dependencyVersionMap.amqplib;
+  devDependencies["@types/amqplib"] = dependencyVersionMap["@types/amqplib"];
+};
+
+// src/installers/infra/redis.ts
+import path19 from "path";
+var redisInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies } = opts;
+  await ensureDir(path19.join(apiDir, "src", "infra", "redis"));
+  envEntries.push(
+    { key: "REDIS_HOST", value: "localhost", category: "Redis" },
+    { key: "REDIS_PORT", value: "6379", category: "Redis" },
+    { key: "REDIS_PASSWORD", value: "", category: "Redis" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path19.join(apiDir, "src", "infra", "redis", "redis.service.ts"), `import { Injectable, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import Redis from 'ioredis';
+
+@Injectable()
+export class RedisService implements OnModuleDestroy {
+  public readonly client: Redis;
+
+  constructor(private configService: ConfigService) {
+    this.client = new Redis({
+      host: this.configService.get('REDIS_HOST', 'localhost'),
+      port: this.configService.get('REDIS_PORT', 6379),
+      password: this.configService.get('REDIS_PASSWORD') || undefined,
+    });
+  }
+
+  async get(key: string): Promise<string | null> {
+    return this.client.get(key);
+  }
+
+  async set(key: string, value: string, ttlSeconds?: number): Promise<void> {
+    if (ttlSeconds) {
+      await this.client.set(key, value, 'EX', ttlSeconds);
+    } else {
+      await this.client.set(key, value);
+    }
+  }
+
+  async del(key: string): Promise<void> {
+    await this.client.del(key);
+  }
+
+  async onModuleDestroy() {
+    await this.client.quit();
+  }
+}
+`);
+    await writeFile(path19.join(apiDir, "src", "infra", "redis", "redis.module.ts"), `import { Global, Module } from '@nestjs/common';
+import { RedisService } from './redis.service';
+
+@Global()
+@Module({
+  providers: [RedisService],
+  exports: [RedisService],
+})
+export class RedisModule {}
+`);
+  } else {
+    await writeFile(path19.join(apiDir, "src", "infra", "redis", "redis.ts"), `import Redis from 'ioredis';
+
+const redis = new Redis({
+  host: process.env.REDIS_HOST || 'localhost',
+  port: Number(process.env.REDIS_PORT) || 6379,
+  password: process.env.REDIS_PASSWORD || undefined,
+});
+
+redis.on('connect', () => console.log('Redis conectado'));
+redis.on('error', (err) => console.error('Redis erro:', err));
+
+export default redis;
+`);
+  }
+  dependencies["ioredis"] = dependencyVersionMap.ioredis;
+};
+
+// src/installers/infra/smtp.ts
+import path20 from "path";
+var smtpInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies, devDependencies } = opts;
+  await ensureDir(path20.join(apiDir, "src", "infra", "email"));
+  await ensureDir(path20.join(apiDir, "src", "infra", "email", "templates"));
+  envEntries.push(
+    { key: "SMTP_HOST", value: "", category: "SMTP", comment: "Ex: smtp.gmail.com" },
+    { key: "SMTP_PORT", value: "587", category: "SMTP" },
+    { key: "SMTP_USER", value: "", category: "SMTP" },
+    { key: "SMTP_PASS", value: "", category: "SMTP" },
+    { key: "SMTP_FROM", value: `noreply@${config.projectName}.com`, category: "SMTP" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path20.join(apiDir, "src", "infra", "email", "email.service.ts"), `import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as nodemailer from 'nodemailer';
+
+@Injectable()
+export class EmailService {
+  private transporter: nodemailer.Transporter;
+
+  constructor(private configService: ConfigService) {
+    this.transporter = nodemailer.createTransport({
+      host: this.configService.get('SMTP_HOST'),
+      port: this.configService.get('SMTP_PORT', 587),
+      secure: false,
+      auth: {
+        user: this.configService.get('SMTP_USER'),
+        pass: this.configService.get('SMTP_PASS'),
+      },
+    });
+  }
+
+  async sendEmail(to: string, subject: string, html: string): Promise<void> {
+    await this.transporter.sendMail({
+      from: this.configService.get('SMTP_FROM'),
+      to,
+      subject,
+      html,
+    });
+  }
+}
+`);
+    await writeFile(path20.join(apiDir, "src", "infra", "email", "email.module.ts"), `import { Global, Module } from '@nestjs/common';
+import { EmailService } from './email.service';
+
+@Global()
+@Module({
+  providers: [EmailService],
+  exports: [EmailService],
+})
+export class EmailModule {}
+`);
+  } else {
+    await writeFile(path20.join(apiDir, "src", "infra", "email", "email.service.ts"), `import nodemailer from 'nodemailer';
+
+const transporter = nodemailer.createTransport({
+  host: process.env.SMTP_HOST,
+  port: Number(process.env.SMTP_PORT) || 587,
+  secure: false,
+  auth: {
+    user: process.env.SMTP_USER,
+    pass: process.env.SMTP_PASS,
+  },
+});
+
+export async function sendEmail(to: string, subject: string, html: string): Promise<void> {
+  await transporter.sendMail({
+    from: process.env.SMTP_FROM,
+    to,
+    subject,
+    html,
+  });
+}
+
+export default { sendEmail };
+`);
+  }
+  await writeFile(path20.join(apiDir, "src", "infra", "email", "templates", "welcome.html"), `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
+    .container { max-width: 600px; margin: 0 auto; background: white; border-radius: 8px; padding: 40px; }
+    h1 { color: #333; }
+    .btn { display: inline-block; padding: 12px 24px; background: #0070f3; color: white; text-decoration: none; border-radius: 6px; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Bem-vindo ao ${config.projectName}!</h1>
+    <p>Sua conta foi criada com sucesso.</p>
+    <a href="{{APP_URL}}" class="btn">Acessar</a>
+  </div>
+</body>
+</html>
+`);
+  dependencies["nodemailer"] = dependencyVersionMap.nodemailer;
+  devDependencies["@types/nodemailer"] = dependencyVersionMap["@types/nodemailer"];
+};
+
+// src/installers/infra/minio.ts
+import path21 from "path";
+var minioInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies } = opts;
+  await ensureDir(path21.join(apiDir, "src", "infra", "storage"));
+  envEntries.push(
+    { key: "MINIO_ENDPOINT", value: "localhost", category: "MinIO Storage" },
+    { key: "MINIO_PORT", value: "9000", category: "MinIO Storage" },
+    { key: "MINIO_ACCESS_KEY", value: "minioadmin", category: "MinIO Storage" },
+    { key: "MINIO_SECRET_KEY", value: "minioadmin", category: "MinIO Storage" },
+    { key: "MINIO_BUCKET", value: config.projectName.replace(/-/g, "-"), category: "MinIO Storage" },
+    { key: "MINIO_USE_SSL", value: "false", category: "MinIO Storage" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path21.join(apiDir, "src", "infra", "storage", "storage.service.ts"), `import { Injectable, OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as Minio from 'minio';
+
+@Injectable()
+export class StorageService implements OnModuleInit {
+  private client: Minio.Client;
+  private bucket: string;
+
+  constructor(private configService: ConfigService) {
+    this.bucket = this.configService.get('MINIO_BUCKET', '${config.projectName}');
+    this.client = new Minio.Client({
+      endPoint: this.configService.get('MINIO_ENDPOINT', 'localhost'),
+      port: this.configService.get('MINIO_PORT', 9000),
+      useSSL: this.configService.get('MINIO_USE_SSL') === 'true',
+      accessKey: this.configService.get('MINIO_ACCESS_KEY', 'minioadmin'),
+      secretKey: this.configService.get('MINIO_SECRET_KEY', 'minioadmin'),
+    });
+  }
+
+  async onModuleInit() {
+    const exists = await this.client.bucketExists(this.bucket);
+    if (!exists) {
+      await this.client.makeBucket(this.bucket);
+      console.log(\`Bucket "\${this.bucket}" criado\`);
+    }
+  }
+
+  async upload(fileName: string, buffer: Buffer, contentType?: string): Promise<string> {
+    await this.client.putObject(this.bucket, fileName, buffer, buffer.length, {
+      'Content-Type': contentType || 'application/octet-stream',
+    });
+    return fileName;
+  }
+
+  async getFileUrl(fileName: string, expirySeconds = 3600): Promise<string> {
+    return this.client.presignedGetObject(this.bucket, fileName, expirySeconds);
+  }
+
+  async delete(fileName: string): Promise<void> {
+    await this.client.removeObject(this.bucket, fileName);
+  }
+}
+`);
+    await writeFile(path21.join(apiDir, "src", "infra", "storage", "storage.module.ts"), `import { Global, Module } from '@nestjs/common';
+import { StorageService } from './storage.service';
+
+@Global()
+@Module({
+  providers: [StorageService],
+  exports: [StorageService],
+})
+export class StorageModule {}
+`);
+  } else {
+    await writeFile(path21.join(apiDir, "src", "infra", "storage", "storage.ts"), `import * as Minio from 'minio';
+
+const BUCKET = process.env.MINIO_BUCKET || '${config.projectName}';
+
+const minioClient = new Minio.Client({
+  endPoint: process.env.MINIO_ENDPOINT || 'localhost',
+  port: Number(process.env.MINIO_PORT) || 9000,
+  useSSL: process.env.MINIO_USE_SSL === 'true',
+  accessKey: process.env.MINIO_ACCESS_KEY || 'minioadmin',
+  secretKey: process.env.MINIO_SECRET_KEY || 'minioadmin',
+});
+
+export async function initStorage(): Promise<void> {
+  const exists = await minioClient.bucketExists(BUCKET);
+  if (!exists) {
+    await minioClient.makeBucket(BUCKET);
+    console.log(\`Bucket "\${BUCKET}" criado\`);
+  }
+}
+
+export async function upload(fileName: string, buffer: Buffer, contentType?: string): Promise<string> {
+  await minioClient.putObject(BUCKET, fileName, buffer, buffer.length, {
+    'Content-Type': contentType || 'application/octet-stream',
+  });
+  return fileName;
+}
+
+export async function getFileUrl(fileName: string, expirySeconds = 3600): Promise<string> {
+  return minioClient.presignedGetObject(BUCKET, fileName, expirySeconds);
+}
+
+export async function deleteFile(fileName: string): Promise<void> {
+  await minioClient.removeObject(BUCKET, fileName);
+}
+
+export default { initStorage, upload, getFileUrl, deleteFile };
+`);
+  }
+  dependencies["minio"] = dependencyVersionMap.minio;
+};
+
+// src/installers/infra/pm2.ts
+import path22 from "path";
+var pm2Installer = async (opts) => {
+  const { config, projectDir, devDependencies, scripts } = opts;
+  const ecosystem = `module.exports = {
+  apps: [
+    {
+      name: '${config.projectName}-api',
+      script: '${config.backend === "nestjs" ? "dist/main.js" : "dist/index.js"}',
+      cwd: './apps/api',
+      instances: 'max',
+      exec_mode: 'cluster',
+      env: {
+        NODE_ENV: 'production',
+        PORT: 3001,
+      },
+      watch: false,
+      max_memory_restart: '1G',
+      // Zero-downtime reload
+      wait_ready: true,
+      listen_timeout: 10000,
+      kill_timeout: 5000,
+    },
+  ],
+};
+`;
+  await writeFile(path22.join(projectDir, "ecosystem.config.cjs"), ecosystem);
+  devDependencies["pm2"] = dependencyVersionMap.pm2;
+  scripts["pm2:start"] = "pm2 start ecosystem.config.cjs";
+  scripts["pm2:stop"] = "pm2 stop ecosystem.config.cjs";
+  scripts["pm2:restart"] = "pm2 reload ecosystem.config.cjs";
+  scripts["pm2:logs"] = "pm2 logs";
+};
+
+// src/installers/multiTenant.ts
+import path23 from "path";
+var multiTenantInstaller = async (opts) => {
+  const { config, apiDir } = opts;
+  await ensureDir(path23.join(apiDir, "src", "tenant"));
+  if (config.backend === "nestjs") {
+    await writeFile(path23.join(apiDir, "src", "tenant", "tenant.middleware.ts"), `import { Injectable, NestMiddleware } from '@nestjs/common';
+import type { Request, Response, NextFunction } from 'express';
+
+@Injectable()
+export class TenantMiddleware implements NestMiddleware {
+  use(req: Request, _res: Response, next: NextFunction) {
+    // Extrair tenant do header, subdomain ou path
+    const tenantId = req.headers['x-tenant-id'] as string
+      || this.extractFromSubdomain(req)
+      || 'default';
+
+    (req as any).tenantId = tenantId;
+    next();
+  }
+
+  private extractFromSubdomain(req: Request): string | null {
+    const host = req.hostname;
+    const parts = host.split('.');
+    if (parts.length >= 3) {
+      return parts[0]; // subdomain como tenant
+    }
+    return null;
+  }
+}
+`);
+    await writeFile(path23.join(apiDir, "src", "tenant", "tenant.decorator.ts"), `import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+export const TenantId = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext): string => {
+    const request = ctx.switchToHttp().getRequest();
+    return request.tenantId || 'default';
+  },
+);
+`);
+    await writeFile(path23.join(apiDir, "src", "tenant", "tenant.module.ts"), `import { Module, MiddlewareConsumer, NestModule } from '@nestjs/common';
+import { TenantMiddleware } from './tenant.middleware';
+
+@Module({})
+export class TenantModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(TenantMiddleware).forRoutes('*');
+  }
+}
+`);
+  } else if (config.backend === "express") {
+    await writeFile(path23.join(apiDir, "src", "tenant", "tenant.middleware.ts"), `import type { Request, Response, NextFunction } from 'express';
+
+export function tenantMiddleware(req: Request, _res: Response, next: NextFunction) {
+  const tenantId = req.headers['x-tenant-id'] as string
+    || extractFromSubdomain(req)
+    || 'default';
+
+  (req as any).tenantId = tenantId;
+  next();
+}
+
+function extractFromSubdomain(req: Request): string | null {
+  const host = req.hostname;
+  const parts = host.split('.');
+  if (parts.length >= 3) {
+    return parts[0];
+  }
+  return null;
+}
+`);
+  } else {
+    await writeFile(path23.join(apiDir, "src", "tenant", "tenant.plugin.ts"), `import type { FastifyInstance, FastifyRequest } from 'fastify';
+import fp from 'fastify-plugin';
+
+declare module 'fastify' {
+  interface FastifyRequest {
+    tenantId: string;
+  }
+}
+
+async function tenantPlugin(app: FastifyInstance) {
+  app.decorateRequest('tenantId', 'default');
+
+  app.addHook('onRequest', async (request: FastifyRequest) => {
+    const tenantId = (request.headers['x-tenant-id'] as string)
+      || extractFromSubdomain(request)
+      || 'default';
+
+    request.tenantId = tenantId;
+  });
+}
+
+function extractFromSubdomain(request: FastifyRequest): string | null {
+  const host = request.hostname;
+  const parts = host.split('.');
+  if (parts.length >= 3) {
+    return parts[0];
+  }
+  return null;
+}
+
+export default fp(tenantPlugin, { name: 'tenant' });
+`);
+  }
+};
+
+// src/installers/integrations/viacep.ts
+import path24 from "path";
+var viacepInstaller = async (opts) => {
+  const { config, apiDir, dependencies } = opts;
+  await ensureDir(path24.join(apiDir, "src", "integrations", "viacep"));
+  const serviceContent = `import axios from 'axios';
+
+export interface ViaCepResponse {
+  cep: string;
+  logradouro: string;
+  complemento: string;
+  bairro: string;
+  localidade: string;
+  uf: string;
+  ibge: string;
+  erro?: boolean;
+}
+
+const VIACEP_URL = 'https://viacep.com.br/ws';
+
+export async function fetchAddress(cep: string): Promise<ViaCepResponse | null> {
+  const cleanCep = cep.replace(/\\D/g, '');
+  if (cleanCep.length !== 8) throw new Error('CEP deve ter 8 d\xEDgitos');
+
+  const { data } = await axios.get<ViaCepResponse>(\`\${VIACEP_URL}/\${cleanCep}/json\`);
+  if (data.erro) return null;
+  return data;
+}
+`;
+  if (config.backend === "nestjs") {
+    await writeFile(path24.join(apiDir, "src", "integrations", "viacep", "viacep.service.ts"), `import { Injectable } from '@nestjs/common';
+import axios from 'axios';
+
+export interface ViaCepResponse {
+  cep: string;
+  logradouro: string;
+  complemento: string;
+  bairro: string;
+  localidade: string;
+  uf: string;
+  ibge: string;
+  erro?: boolean;
+}
+
+@Injectable()
+export class ViaCepService {
+  private readonly baseUrl = 'https://viacep.com.br/ws';
+
+  async fetchAddress(cep: string): Promise<ViaCepResponse | null> {
+    const cleanCep = cep.replace(/\\D/g, '');
+    if (cleanCep.length !== 8) throw new Error('CEP deve ter 8 d\xEDgitos');
+
+    const { data } = await axios.get<ViaCepResponse>(\`\${this.baseUrl}/\${cleanCep}/json\`);
+    if (data.erro) return null;
+    return data;
+  }
+}
+`);
+  } else {
+    await writeFile(path24.join(apiDir, "src", "integrations", "viacep", "viacep.service.ts"), serviceContent);
+  }
+  dependencies["axios"] = dependencyVersionMap.axios;
+};
+
+// src/installers/integrations/whatsapp.ts
+import path25 from "path";
+var whatsappInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies } = opts;
+  await ensureDir(path25.join(apiDir, "src", "integrations", "whatsapp"));
+  envEntries.push(
+    { key: "WHATSAPP_API_TOKEN", value: "", category: "WhatsApp", comment: "Token da API Meta WhatsApp Business" },
+    { key: "WHATSAPP_PHONE_ID", value: "", category: "WhatsApp" },
+    { key: "WHATSAPP_VERIFY_TOKEN", value: "my-verify-token", category: "WhatsApp", comment: "Token de verificacao do webhook" }
+  );
+  const serviceContent = config.backend === "nestjs" ? `import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+
+@Injectable()
+export class WhatsAppService {
+  private readonly apiUrl: string;
+  private readonly token: string;
+
+  constructor(private configService: ConfigService) {
+    const phoneId = this.configService.get('WHATSAPP_PHONE_ID');
+    this.apiUrl = \`https://graph.facebook.com/v18.0/\${phoneId}/messages\`;
+    this.token = this.configService.get('WHATSAPP_API_TOKEN', '');
+  }
+
+  async sendMessage(to: string, message: string): Promise<void> {
+    await axios.post(
+      this.apiUrl,
+      {
+        messaging_product: 'whatsapp',
+        to,
+        type: 'text',
+        text: { body: message },
+      },
+      {
+        headers: {
+          Authorization: \`Bearer \${this.token}\`,
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+  }
+
+  async sendTemplate(to: string, templateName: string, language = 'pt_BR'): Promise<void> {
+    await axios.post(
+      this.apiUrl,
+      {
+        messaging_product: 'whatsapp',
+        to,
+        type: 'template',
+        template: { name: templateName, language: { code: language } },
+      },
+      {
+        headers: {
+          Authorization: \`Bearer \${this.token}\`,
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+  }
+}
+` : `import axios from 'axios';
+
+const PHONE_ID = process.env.WHATSAPP_PHONE_ID;
+const API_URL = \`https://graph.facebook.com/v18.0/\${PHONE_ID}/messages\`;
+const TOKEN = process.env.WHATSAPP_API_TOKEN || '';
+
+const headers = {
+  Authorization: \`Bearer \${TOKEN}\`,
+  'Content-Type': 'application/json',
+};
+
+export async function sendMessage(to: string, message: string): Promise<void> {
+  await axios.post(API_URL, {
+    messaging_product: 'whatsapp',
+    to,
+    type: 'text',
+    text: { body: message },
+  }, { headers });
+}
+
+export async function sendTemplate(to: string, templateName: string, language = 'pt_BR'): Promise<void> {
+  await axios.post(API_URL, {
+    messaging_product: 'whatsapp',
+    to,
+    type: 'template',
+    template: { name: templateName, language: { code: language } },
+  }, { headers });
+}
+`;
+  await writeFile(path25.join(apiDir, "src", "integrations", "whatsapp", "whatsapp.service.ts"), serviceContent);
+  dependencies["axios"] = dependencyVersionMap.axios;
+};
+
+// src/installers/integrations/stripe.ts
+import path26 from "path";
+var stripeInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies } = opts;
+  await ensureDir(path26.join(apiDir, "src", "integrations", "stripe"));
+  envEntries.push(
+    { key: "STRIPE_SECRET_KEY", value: "", category: "Stripe", comment: "Obtenha em https://dashboard.stripe.com" },
+    { key: "STRIPE_WEBHOOK_SECRET", value: "", category: "Stripe" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path26.join(apiDir, "src", "integrations", "stripe", "stripe.service.ts"), `import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import Stripe from 'stripe';
+
+@Injectable()
+export class StripeService {
+  private stripe: Stripe;
+
+  constructor(private configService: ConfigService) {
+    this.stripe = new Stripe(this.configService.get('STRIPE_SECRET_KEY', ''), {
+      apiVersion: '2024-12-18.acacia',
+    });
+  }
+
+  async createCheckoutSession(params: {
+    priceId: string;
+    successUrl: string;
+    cancelUrl: string;
+    customerEmail?: string;
+  }) {
+    return this.stripe.checkout.sessions.create({
+      mode: 'subscription',
+      payment_method_types: ['card'],
+      line_items: [{ price: params.priceId, quantity: 1 }],
+      success_url: params.successUrl,
+      cancel_url: params.cancelUrl,
+      customer_email: params.customerEmail,
+    });
+  }
+
+  async createPaymentIntent(amount: number, currency = 'brl') {
+    return this.stripe.paymentIntents.create({
+      amount,
+      currency,
+    });
+  }
+
+  constructWebhookEvent(body: Buffer, signature: string) {
+    const webhookSecret = this.configService.get('STRIPE_WEBHOOK_SECRET', '');
+    return this.stripe.webhooks.constructEvent(body, signature, webhookSecret);
+  }
+}
+`);
+  } else {
+    await writeFile(path26.join(apiDir, "src", "integrations", "stripe", "stripe.service.ts"), `import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY || '', {
+  apiVersion: '2024-12-18.acacia',
+});
+
+export async function createCheckoutSession(params: {
+  priceId: string;
+  successUrl: string;
+  cancelUrl: string;
+  customerEmail?: string;
+}) {
+  return stripe.checkout.sessions.create({
+    mode: 'subscription',
+    payment_method_types: ['card'],
+    line_items: [{ price: params.priceId, quantity: 1 }],
+    success_url: params.successUrl,
+    cancel_url: params.cancelUrl,
+    customer_email: params.customerEmail,
+  });
+}
+
+export async function createPaymentIntent(amount: number, currency = 'brl') {
+  return stripe.paymentIntents.create({ amount, currency });
+}
+
+export function constructWebhookEvent(body: Buffer, signature: string) {
+  return stripe.webhooks.constructEvent(
+    body,
+    signature,
+    process.env.STRIPE_WEBHOOK_SECRET || ''
+  );
+}
+`);
+  }
+  dependencies["stripe"] = dependencyVersionMap.stripe;
+};
+
+// src/installers/integrations/mercadoPago.ts
+import path27 from "path";
+var mercadoPagoInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies } = opts;
+  await ensureDir(path27.join(apiDir, "src", "integrations", "mercado-pago"));
+  envEntries.push(
+    { key: "MERCADOPAGO_ACCESS_TOKEN", value: "", category: "Mercado Pago", comment: "Obtenha em https://www.mercadopago.com.br/developers" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path27.join(apiDir, "src", "integrations", "mercado-pago", "mercado-pago.service.ts"), `import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { MercadoPagoConfig, Preference, Payment } from 'mercadopago';
+
+@Injectable()
+export class MercadoPagoService {
+  private client: MercadoPagoConfig;
+
+  constructor(private configService: ConfigService) {
+    this.client = new MercadoPagoConfig({
+      accessToken: this.configService.get('MERCADOPAGO_ACCESS_TOKEN', ''),
+    });
+  }
+
+  async createPreference(params: {
+    title: string;
+    quantity: number;
+    unitPrice: number;
+    successUrl?: string;
+    failureUrl?: string;
+  }) {
+    const preference = new Preference(this.client);
+    return preference.create({
+      body: {
+        items: [
+          {
+            id: 'item-1',
+            title: params.title,
+            quantity: params.quantity,
+            unit_price: params.unitPrice,
+            currency_id: 'BRL',
+          },
+        ],
+        back_urls: {
+          success: params.successUrl || 'http://localhost:3000/success',
+          failure: params.failureUrl || 'http://localhost:3000/failure',
+        },
+        auto_return: 'approved',
+      },
+    });
+  }
+
+  async getPayment(paymentId: string) {
+    const payment = new Payment(this.client);
+    return payment.get({ id: paymentId });
+  }
+}
+`);
+  } else {
+    await writeFile(path27.join(apiDir, "src", "integrations", "mercado-pago", "mercado-pago.service.ts"), `import { MercadoPagoConfig, Preference, Payment } from 'mercadopago';
+
+const client = new MercadoPagoConfig({
+  accessToken: process.env.MERCADOPAGO_ACCESS_TOKEN || '',
+});
+
+export async function createPreference(params: {
+  title: string;
+  quantity: number;
+  unitPrice: number;
+  successUrl?: string;
+  failureUrl?: string;
+}) {
+  const preference = new Preference(client);
+  return preference.create({
+    body: {
+      items: [
+        {
+          id: 'item-1',
+          title: params.title,
+          quantity: params.quantity,
+          unit_price: params.unitPrice,
+          currency_id: 'BRL',
+        },
+      ],
+      back_urls: {
+        success: params.successUrl || 'http://localhost:3000/success',
+        failure: params.failureUrl || 'http://localhost:3000/failure',
+      },
+      auto_return: 'approved',
+    },
+  });
+}
+
+export async function getPayment(paymentId: string) {
+  const payment = new Payment(client);
+  return payment.get({ id: paymentId });
+}
+`);
+  }
+  dependencies["mercadopago"] = dependencyVersionMap.mercadopago;
+};
+
+// src/installers/integrations/abacatePay.ts
+import path28 from "path";
+var abacatePayInstaller = async (opts) => {
+  const { config, apiDir, envEntries, dependencies } = opts;
+  await ensureDir(path28.join(apiDir, "src", "integrations", "abacate-pay"));
+  envEntries.push(
+    { key: "ABACATEPAY_API_KEY", value: "", category: "AbacatePay", comment: "Obtenha em https://abacatepay.com" },
+    { key: "ABACATEPAY_API_URL", value: "https://api.abacatepay.com/v1", category: "AbacatePay" }
+  );
+  if (config.backend === "nestjs") {
+    await writeFile(path28.join(apiDir, "src", "integrations", "abacate-pay", "abacate-pay.service.ts"), `import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import axios, { type AxiosInstance } from 'axios';
+
+@Injectable()
+export class AbacatePayService {
+  private client: AxiosInstance;
+
+  constructor(private configService: ConfigService) {
+    this.client = axios.create({
+      baseURL: this.configService.get('ABACATEPAY_API_URL', 'https://api.abacatepay.com/v1'),
+      headers: {
+        Authorization: \`Bearer \${this.configService.get('ABACATEPAY_API_KEY')}\`,
+        'Content-Type': 'application/json',
+      },
+    });
+  }
+
+  async createPayment(params: {
+    amount: number;
+    description: string;
+    customerEmail: string;
+  }) {
+    const { data } = await this.client.post('/payments', {
+      amount: params.amount,
+      description: params.description,
+      customer: { email: params.customerEmail },
+    });
+    return data;
+  }
+
+  async getPayment(paymentId: string) {
+    const { data } = await this.client.get(\`/payments/\${paymentId}\`);
+    return data;
+  }
+
+  async createPixPayment(params: {
+    amount: number;
+    description: string;
+    customerEmail: string;
+  }) {
+    const { data } = await this.client.post('/payments/pix', {
+      amount: params.amount,
+      description: params.description,
+      customer: { email: params.customerEmail },
+    });
+    return data;
+  }
+}
+`);
+  } else {
+    await writeFile(path28.join(apiDir, "src", "integrations", "abacate-pay", "abacate-pay.service.ts"), `import axios from 'axios';
+
+const API_URL = process.env.ABACATEPAY_API_URL || 'https://api.abacatepay.com/v1';
+const API_KEY = process.env.ABACATEPAY_API_KEY || '';
+
+const client = axios.create({
+  baseURL: API_URL,
+  headers: {
+    Authorization: \`Bearer \${API_KEY}\`,
+    'Content-Type': 'application/json',
+  },
+});
+
+export async function createPayment(params: {
+  amount: number;
+  description: string;
+  customerEmail: string;
+}) {
+  const { data } = await client.post('/payments', {
+    amount: params.amount,
+    description: params.description,
+    customer: { email: params.customerEmail },
+  });
+  return data;
+}
+
+export async function getPayment(paymentId: string) {
+  const { data } = await client.get(\`/payments/\${paymentId}\`);
+  return data;
+}
+
+export async function createPixPayment(params: {
+  amount: number;
+  description: string;
+  customerEmail: string;
+}) {
+  const { data } = await client.post('/payments/pix', {
+    amount: params.amount,
+    description: params.description,
+    customer: { email: params.customerEmail },
+  });
+  return data;
+}
+`);
+  }
+  dependencies["axios"] = dependencyVersionMap.axios;
+};
+
+// src/installers/index.ts
+function buildInstallerMap(config) {
+  return {
+    // Database (must run before auth since auth may depend on user model)
+    "Prisma": {
+      inUse: config.usePrisma,
+      installer: prismaInstaller
+    },
+    "Mongoose": {
+      inUse: config.useMongoose,
+      installer: mongooseInstaller
+    },
+    // Multi-tenant (after database)
+    "Multi-tenant": {
+      inUse: config.multiTenant,
+      installer: multiTenantInstaller
+    },
+    // Infrastructure
+    "Redis": {
+      inUse: config.redis,
+      installer: redisInstaller
+    },
+    "SMTP": {
+      inUse: config.smtp,
+      installer: smtpInstaller
+    },
+    "MinIO": {
+      inUse: config.minio,
+      installer: minioInstaller
+    },
+    "PM2": {
+      inUse: config.pm2,
+      installer: pm2Installer
+    },
+    // Auth
+    "JWT Auth": {
+      inUse: config.auth.jwt,
+      installer: jwtInstaller
+    },
+    "Magic Link": {
+      inUse: config.auth.magicLink,
+      installer: magicLinkInstaller
+    },
+    "Google OAuth": {
+      inUse: config.auth.googleOAuth,
+      installer: googleOauthInstaller
+    },
+    // Queues
+    "BullMQ": {
+      inUse: config.queue === "bullmq",
+      installer: bullmqInstaller
+    },
+    "RabbitMQ": {
+      inUse: config.queue === "rabbitmq",
+      installer: rabbitmqInstaller
+    },
+    // Integrations
+    "ViaCEP": {
+      inUse: config.integrations.viacep,
+      installer: viacepInstaller
+    },
+    "WhatsApp": {
+      inUse: config.integrations.whatsapp,
+      installer: whatsappInstaller
+    },
+    "Stripe": {
+      inUse: config.integrations.stripe,
+      installer: stripeInstaller
+    },
+    "Mercado Pago": {
+      inUse: config.integrations.mercadoPago,
+      installer: mercadoPagoInstaller
+    },
+    "AbacatePay": {
+      inUse: config.integrations.abacatePay,
+      installer: abacatePayInstaller
+    }
+  };
+}
+
+// src/helpers/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({ text, color: "cyan" });
+}
+async function withSpinner(text, fn) {
+  const spinner = createSpinner(text);
+  spinner.start();
+  try {
+    const result = await fn();
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+}
+
+// src/helpers/git.ts
+import { execa as execa2 } from "execa";
+async function initGit(projectDir) {
+  await execa2("git", ["init"], { cwd: projectDir });
+  await execa2("git", ["add", "-A"], { cwd: projectDir });
+  await execa2("git", ["commit", "-m", "chore: initial commit from plazercli"], {
+    cwd: projectDir
+  });
+}
+
+// src/helpers/packages.ts
+import path29 from "path";
+async function readPackageJson(dir) {
+  const content = await readFile(path29.join(dir, "package.json"));
+  return JSON.parse(content);
+}
+async function writePackageJson(dir, pkg2) {
+  await writeFile(path29.join(dir, "package.json"), JSON.stringify(pkg2, null, 2) + "\n");
+}
+function sortDeps(pkg2) {
+  if (pkg2.dependencies) {
+    pkg2.dependencies = Object.fromEntries(
+      Object.entries(pkg2.dependencies).sort(([a], [b]) => a.localeCompare(b))
+    );
+  }
+  if (pkg2.devDependencies) {
+    pkg2.devDependencies = Object.fromEntries(
+      Object.entries(pkg2.devDependencies).sort(([a], [b]) => a.localeCompare(b))
+    );
+  }
+  return pkg2;
+}
+
+// src/generators/project.ts
+async function generateProject(config) {
+  const projectDir = config.projectDir;
+  const apiDir = path30.join(projectDir, "apps", "api");
+  const webDir = path30.join(projectDir, "apps", "web");
+  const envEntries = [];
+  const dependencies = {};
+  const devDependencies = {};
+  const scripts = {};
+  const dockerServices = [];
+  const opts = {
+    config,
+    projectDir,
+    apiDir,
+    webDir,
+    envEntries,
+    dependencies,
+    devDependencies,
+    scripts,
+    dockerServices
+  };
+  console.log(chalk2.cyan("\n  Liz est\xE1 preparando seu projeto...\n"));
+  await withSpinner("Criando estrutura do monorepo...", async () => {
+    await generateBase(config);
+  });
+  await withSpinner(`Configurando frontend (${config.frontend})...`, async () => {
+    await generateFrontend(config, webDir);
+  });
+  await withSpinner(`Configurando backend (${config.backend})...`, async () => {
+    await generateBackend(config, apiDir);
+  });
+  const installerMap = buildInstallerMap(config);
+  for (const [name, entry] of Object.entries(installerMap)) {
+    if (entry.inUse) {
+      await withSpinner(`Configurando ${name}...`, async () => {
+        await entry.installer(opts);
+      });
+    }
+  }
+  if (Object.keys(dependencies).length > 0 || Object.keys(devDependencies).length > 0 || Object.keys(scripts).length > 0) {
+    const apiPkg = await readPackageJson(apiDir);
+    if (!apiPkg.dependencies) apiPkg.dependencies = {};
+    if (!apiPkg.devDependencies) apiPkg.devDependencies = {};
+    if (!apiPkg.scripts) apiPkg.scripts = {};
+    Object.assign(apiPkg.dependencies, dependencies);
+    Object.assign(apiPkg.devDependencies, devDependencies);
+    Object.assign(apiPkg.scripts, scripts);
+    await writePackageJson(apiDir, sortDeps(apiPkg));
+  }
+  await withSpinner("Conectando m\xF3dulos automaticamente...", async () => {
+    await generateWiring(config, apiDir);
+  });
+  if (config.database !== "none" || config.redis || config.queue === "rabbitmq" || config.minio) {
+    await withSpinner("Gerando docker-compose.yml...", async () => {
+      await generateDocker(config, projectDir, dockerServices);
+    });
+  }
+  await withSpinner("Gerando arquivos .env...", async () => {
+    await generateEnv(config, apiDir, envEntries);
+  });
+  await withSpinner("Gerando README.md...", async () => {
+    await generateReadme(config, projectDir);
+  });
+  await withSpinner("Configurando Liz (AI Agent)...", async () => {
+    await generateLiz(config, projectDir);
+  });
+  let installResult = { success: false };
+  try {
+    await withSpinner(`Instalando depend\xEAncias (${config.runtime})...`, async () => {
+      installResult = await installDependencies(projectDir, config.runtime);
+    });
+    if (installResult.fallback) {
+      logger.warn(`${config.runtime} n\xE3o encontrado. Depend\xEAncias instaladas com ${installResult.fallback}.`);
+    }
+  } catch {
+    logger.warn(`N\xE3o foi poss\xEDvel instalar depend\xEAncias automaticamente.`);
+    logger.info(`Rode manualmente: cd ${config.projectName} && ${config.runtime} install`);
+  }
+  try {
+    await withSpinner("Inicializando reposit\xF3rio git...", async () => {
+      await initGit(projectDir);
+    });
+  } catch {
+    logger.warn("Git n\xE3o encontrado. Inicialize manualmente com: git init");
+  }
+  printNextSteps(config, installResult.success);
+}
+function printNextSteps(config, depsInstalled = true) {
+  const runCmd = getRunCommand(config.runtime);
+  const hasDocker = config.database !== "none" || config.redis || config.queue === "rabbitmq" || config.minio;
+  const authMethods = [
+    config.auth.jwt && "JWT",
+    config.auth.magicLink && "Magic Link",
+    config.auth.googleOAuth && "Google OAuth"
+  ].filter(Boolean);
+  const integrations = Object.entries(config.integrations).filter(([, v]) => v).map(([k]) => k);
+  console.log(
+    chalk2.bold.green(`
+  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+  \u2551                                                   \u2551
+  \u2551   \u2705  Projeto "${config.projectName}" criado!     \u2551
+  \u2551       Tudo configurado pela Liz                   \u2551
+  \u2551                                                   \u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`)
+  );
+  console.log(chalk2.bold.white("  O que a Liz configurou pra voc\xEA:\n"));
+  console.log(chalk2.green("  \u2714 ") + chalk2.white(`Frontend ${chalk2.cyan(config.frontend)} pronto em apps/web/`));
+  console.log(chalk2.green("  \u2714 ") + chalk2.white(`Backend ${chalk2.cyan(config.backend)} pronto em apps/api/`));
+  if (config.database !== "none") {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`Banco ${chalk2.cyan(config.database)} configurado com nome "${chalk2.cyan(config.projectName.replace(/-/g, "_"))}"`));
+  }
+  if (authMethods.length > 0) {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`Autentica\xE7\xE3o: ${chalk2.cyan(authMethods.join(", "))} com rotas prontas`));
+  }
+  if (config.redis) {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`Redis configurado e conectado`));
+  }
+  if (config.queue !== "none") {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`Filas ${chalk2.cyan(config.queue)} com worker de exemplo`));
+  }
+  if (config.smtp) {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`SMTP com servi\xE7o de email e template HTML`));
+  }
+  if (config.minio) {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`MinIO storage com upload/download prontos`));
+  }
+  if (config.multiTenant) {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`Multi-tenant com middleware de isolamento`));
+  }
+  if (config.pm2) {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`PM2 com cluster mode para zero-downtime`));
+  }
+  if (integrations.length > 0) {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`Integra\xE7\xF5es: ${chalk2.cyan(integrations.join(", "))}`));
+  }
+  console.log(chalk2.green("  \u2714 ") + chalk2.white(`Liz (AI Agent) configurada para te ajudar`));
+  if (hasDocker) {
+    console.log(chalk2.green("  \u2714 ") + chalk2.white(`Docker Compose com todos os servi\xE7os`));
+  }
+  console.log(chalk2.bold.white("\n  Pr\xF3ximos passos:\n"));
+  let step = 1;
+  console.log(chalk2.white(`  ${step}. ${chalk2.cyan(`cd ${config.projectName}`)}`));
+  step++;
+  if (!depsInstalled) {
+    console.log(chalk2.white(`  ${step}. ${chalk2.cyan(`${config.runtime} install`)}`));
+    console.log(chalk2.gray("     Instala as depend\xEAncias do projeto"));
+    step++;
+  }
+  if (hasDocker) {
+    console.log(chalk2.white(`  ${step}. ${chalk2.cyan("docker compose up -d")}`));
+    console.log(chalk2.gray("     Sobe banco, redis, minio, etc em containers"));
+    step++;
+  }
+  if (config.usePrisma) {
+    console.log(chalk2.white(`  ${step}. ${chalk2.cyan("cd apps/api && npx prisma db push && cd ../..")}`));
+    console.log(chalk2.gray("     Cria as tabelas no banco de dados"));
+    step++;
+  }
+  console.log(chalk2.white(`  ${step}. ${chalk2.cyan(`${runCmd} dev`)}`));
+  console.log(chalk2.gray("     Inicia frontend e API em modo desenvolvimento"));
+  console.log(chalk2.bold.white("\n  URLs:\n"));
+  console.log(chalk2.white(`  Frontend:  ${chalk2.cyan("http://localhost:3000")}`));
+  console.log(chalk2.white(`  API:       ${chalk2.cyan("http://localhost:3001")}`));
+  console.log(chalk2.white(`  Health:    ${chalk2.cyan("http://localhost:3001/api/health")}`));
+  if (config.usePrisma) {
+    console.log(chalk2.white(`  DB Studio: ${chalk2.cyan("npx prisma studio")} (na pasta apps/api)`));
+  }
+  if (config.queue === "rabbitmq") {
+    console.log(chalk2.white(`  RabbitMQ:  ${chalk2.cyan("http://localhost:15672")} (guest/guest)`));
+  }
+  if (config.minio) {
+    console.log(chalk2.white(`  MinIO:     ${chalk2.cyan("http://localhost:9001")} (minioadmin/minioadmin)`));
+  }
+  if (config.pm2) {
+    console.log(chalk2.bold.white("\n  Produ\xE7\xE3o com PM2:\n"));
+    console.log(chalk2.white(`  ${chalk2.cyan(`${runCmd} build`)} && ${chalk2.cyan("pm2 start ecosystem.config.cjs")}`));
+  }
+  console.log(chalk2.gray(`
+  Precisa de ajuda? A Liz est\xE1 dispon\xEDvel no seu editor.`));
+  console.log(chalk2.gray(`  Documenta\xE7\xE3o: https://github.com/pablocarss/plazercli
+`));
+}
+
+// src/index.ts
+import { confirm as confirm2 } from "@inquirer/prompts";
+async function main() {
+  const flags = parseArgs();
+  printBanner();
+  const config = await runPrompts(flags);
+  printSummary(config);
+  const confirmed = await confirm2({
+    message: "\u2705 Confirma a cria\xE7\xE3o do projeto com essas configura\xE7\xF5es?",
+    default: true
+  });
+  if (!confirmed) {
+    logger.warn("Cria\xE7\xE3o cancelada.");
+    process.exit(0);
+  }
+  await generateProject(config);
+}
+main().catch((error) => {
+  logger.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map