@nimbuslab/cli 0.16.3 → 0.16.5

package/src/commands/create.ts

@@ -1,1323 +0,0 @@
-import * as p from "@clack/prompts"
-import pc from "picocolors"
-import { $ } from "bun"
-import { rm, mkdir } from "node:fs/promises"
-import { join } from "node:path"
-
-// AI Assistant configs
-const AI_CONFIGS: Record<string, { filename: string; content: (type: string) => string }> = {
-  claude: {
-    filename: "CLAUDE.md",
-    content: (type) => `# ${type === "landing" ? "Landing Page" : type === "app" ? "Web App" : "Monorepo"}
-
-## Stack
-- Next.js 16 (App Router, Turbopack)
-- React 19 (Server Components)
-- TypeScript (strict)
-- Tailwind CSS 4
-- shadcn/ui
-- Bun
-${type === "app" ? "- Better Auth\n- Drizzle + PostgreSQL" : ""}
-
-## Commands
-\`\`\`bash
-bun dev      # Start development
-bun build    # Production build
-bun lint     # Run ESLint
-${type === "app" ? "bun setup    # Setup database" : ""}
-\`\`\`
-
-## Conventions
-- Use \`bun\` for all package operations
-- Server Components by default
-- Dark mode first design
-- Use \`cn()\` for conditional classes
-- Add components: \`bunx --bun shadcn@latest add [component]\`
-`,
-  },
-  cursor: {
-    filename: ".cursorrules",
-    content: (type) => `# Cursor Rules
-
-Stack: Next.js 16, React 19, TypeScript, Tailwind CSS 4, shadcn/ui, Bun
-${type === "app" ? "Auth: Better Auth | DB: Drizzle + PostgreSQL" : ""}
-
-- Server Components by default
-- "use client" only when needed
-- Tailwind utility classes
-- cn() for conditional classes
-- Dark mode first
-`,
-  },
-  gemini: {
-    filename: ".gemini/GEMINI.md",
-    content: (type) => `# ${type === "landing" ? "Landing Page" : type === "app" ? "Web App" : "Monorepo"}
-
-## Stack
-- Next.js 16 (App Router, Turbopack)
-- React 19 (Server Components)
-- TypeScript (strict)
-- Tailwind CSS 4
-- shadcn/ui
-- Bun
-${type === "app" ? "- Better Auth\n- Drizzle + PostgreSQL" : ""}
-
-## Conventions
-- Use \`bun\` for all package operations
-- Server Components by default
-- Dark mode first design
-- Use \`cn()\` for conditional classes
-`,
-  },
-  copilot: {
-    filename: ".github/copilot-instructions.md",
-    content: (type) => `# GitHub Copilot Instructions
-
-Stack: Next.js 16, React 19, TypeScript, Tailwind CSS 4, shadcn/ui, Bun
-${type === "app" ? "Auth: Better Auth | DB: Drizzle + PostgreSQL" : ""}
-
-## Do
-- Use TypeScript strict mode
-- Prefer Server Components
-- Use Tailwind for styling
-- Use cn() for class merging
-
-## Don't
-- Use CSS modules or styled-components
-- Use class components
-- Add unnecessary dependencies
-`,
-  },
-  windsurf: {
-    filename: ".windsurfrules",
-    content: (type) => `# Windsurf Rules
-
-Stack: Next.js 16, React 19, TypeScript, Tailwind CSS 4, shadcn/ui, Bun
-${type === "app" ? "Auth: Better Auth | DB: Drizzle + PostgreSQL" : ""}
-
-- Server Components by default
-- "use client" only when needed
-- Tailwind utility classes
-- cn() for conditional classes
-- Dark mode first
-`,
-  },
-}
-
-// GitHub CLI check
-async function checkGitHubCli(): Promise<{
-  installed: boolean
-  authenticated: boolean
-  username: string | null
-  orgs: string[]
-}> {
-  const checkCmd = process.platform === "win32" ? "where" : "which"
-  try {
-    const hasGh = await $`${checkCmd} gh`.quiet().nothrow()
-    if (hasGh.exitCode !== 0) {
-      return { installed: false, authenticated: false, username: null, orgs: [] }
-    }
-
-    const authStatus = await $`gh auth status`.quiet().nothrow()
-    if (authStatus.exitCode !== 0) {
-      return { installed: true, authenticated: false, username: null, orgs: [] }
-    }
-
-    const username = (await $`gh api user --jq '.login'`.quiet().text()).trim()
-    const orgsJson = await $`gh api user/orgs --jq '.[].login'`.quiet().text()
-    const orgs = orgsJson.trim().split("\n").filter(Boolean)
-
-    return { installed: true, authenticated: true, username, orgs }
-  } catch {
-    return { installed: false, authenticated: false, username: null, orgs: [] }
-  }
-}
-
-// Templates privados (nimbuslab-templates) - uso interno
-const PRIVATE_TEMPLATES = {
-  "fast": "nimbuslab-templates/fast-template",
-  "fast+": "nimbuslab-templates/fastplus-template",
-  "fast+-monorepo": "nimbuslab-templates/fastplus-monorepo-template",
-  "nimbus-core": "nimbuslab/nimbus-core",
-}
-
-// Templates públicos (nimbuslab)
-const PUBLIC_TEMPLATES = {
-  "landing": "nimbuslab/create-next-landing",
-  "app": "nimbuslab/create-next-app",
-  "turborepo": "nimbuslab/create-turborepo",
-}
-
-// Todos os templates
-const TEMPLATES = { ...PRIVATE_TEMPLATES, ...PUBLIC_TEMPLATES }
-
-// Dominios nimbuslab para deteccao de membros
-const NIMBUSLAB_DOMAINS = ["@nimbuslab.com.br", "@nimbuslab.net.br"]
-
-// Detectar se é membro da nimbuslab (verifica apenas dominio do email)
-async function isNimbuslabMember(): Promise<{ isMember: boolean; user: string | null; email: string | null }> {
-  try {
-    const user = (await $`git config user.name`.text()).trim()
-    const email = (await $`git config user.email`.text()).trim()
-
-    // Verifica se email termina com dominio nimbuslab
-    const isMember = NIMBUSLAB_DOMAINS.some(domain => email.endsWith(domain))
-
-    return { isMember, user, email }
-  } catch {
-    return { isMember: false, user: null, email: null }
-  }
-}
-
-type ProjectType = "fast" | "fast+" | "landing" | "app" | "turborepo" | "nimbus-core"
-
-interface ProjectConfig {
-  name: string
-  type: ProjectType
-  monorepo: boolean
-  git: boolean
-  install: boolean
-  github: boolean
-  githubOrg: string | null
-  githubDescription: string
-  // Public template configs
-  theme: "dark" | "light" | "system"
-  aiAssistant: string | null
-  // M26: Número do contrato (fast only)
-  contractNumber: string
-  // M21-M23: Configs de infra
-  resendApiKey: string
-  resendFromEmail: string
-  contactEmail: string
-  // M30: Railway via CLI
-  railwayProject: string
-  railwayToken: string
-  stagingUrl: string
-  productionUrl: string
-  // Template customizado
-  customTemplate: string | null
-  // nimbus-core: URL do repo do cliente
-  clientRepoUrl?: string | null
-}
-
-interface CreateFlags {
-  yes: boolean
-  // Templates
-  landing: boolean
-  app: boolean
-  turborepo: boolean
-  // Templates internos nimbuslab
-  fast: boolean
-  fastPlus: boolean
-  fastTurborepo: boolean
-  core: boolean
-  // Outros
-  noGit: boolean
-  noInstall: boolean
-  railway: boolean
-  template: string | null
-}
-
-function parseFlags(args: string[]): { flags: CreateFlags; projectName: string | undefined } {
-  const flags: CreateFlags = {
-    yes: false,
-    landing: false,
-    app: false,
-    turborepo: false,
-    fast: false,
-    fastPlus: false,
-    fastTurborepo: false,
-    core: false,
-    noGit: false,
-    noInstall: false,
-    railway: false,
-    template: null,
-  }
-
-  let projectName: string | undefined
-  let i = 0
-
-  while (i < args.length) {
-    const arg = args[i]!
-
-    if (arg === "-y" || arg === "--yes") {
-      flags.yes = true
-    } else if (arg === "--landing") {
-      flags.landing = true
-    } else if (arg === "--app") {
-      flags.app = true
-    } else if (arg === "--turborepo") {
-      flags.turborepo = true
-    } else if (arg === "--fast") {
-      flags.fast = true
-    } else if (arg === "--fast-plus") {
-      flags.fastPlus = true
-    } else if (arg === "--fast-turborepo") {
-      flags.fastTurborepo = true
-    } else if (arg === "--core") {
-      flags.core = true
-    } else if (arg === "--no-git") {
-      flags.noGit = true
-    } else if (arg === "--no-install") {
-      flags.noInstall = true
-    } else if (arg === "--railway") {
-      flags.railway = true
-    } else if (arg === "--template") {
-      i++
-      flags.template = args[i] ?? null
-    } else if (!arg.startsWith("-")) {
-      projectName = arg
-    }
-
-    i++
-  }
-
-  return { flags, projectName }
-}
-
-// M30: Verificar e instalar Railway CLI
-async function ensureRailwayCli(): Promise<boolean> {
-  const checkCmd = process.platform === "win32" ? "where" : "which"
-  const hasRailway = await $`${checkCmd} railway`.quiet().then(() => true).catch(() => false)
-
-  if (hasRailway) return true
-
-  console.log(pc.yellow("Railway CLI not found. Installing..."))
-  console.log()
-
-  try {
-    if (process.platform === "win32") {
-      await $`powershell -c "iwr https://railway.app/install.ps1 -useb | iex"`.quiet()
-    } else {
-      await $`curl -fsSL https://railway.app/install.sh | sh`.quiet()
-    }
-    console.log(pc.green("Railway CLI installed successfully!"))
-    return true
-  } catch (error) {
-    console.log(pc.red("Error installing Railway CLI."))
-    console.log(pc.dim("Install manually: https://docs.railway.app/guides/cli"))
-    return false
-  }
-}
-
-// M30: Listar projetos Railway via CLI
-async function listRailwayProjects(): Promise<string[]> {
-  try {
-    const result = await $`railway list`.text()
-    // Parse output: primeira linha é o team, demais são projetos
-    const lines = result.trim().split("\n").filter(l => l.trim())
-    // Remove primeira linha (team name) e extrai nomes dos projetos
-    return lines.slice(1).map(l => l.trim())
-  } catch {
-    return []
-  }
-}
-
-// M30: Verificar autenticacao Railway
-async function isRailwayAuthenticated(): Promise<boolean> {
-  try {
-    await $`railway whoami`.quiet()
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function create(args: string[]) {
-  // Verifica dependencias (cross-platform)
-  const checkCmd = process.platform === "win32" ? "where" : "which"
-  const hasBun = await $`${checkCmd} bun`.quiet().then(() => true).catch(() => false)
-  const hasGit = await $`${checkCmd} git`.quiet().then(() => true).catch(() => false)
-  const hasGh = await $`${checkCmd} gh`.quiet().then(() => true).catch(() => false)
-
-  if (!hasBun) {
-    console.log(pc.red("Error: Bun not found."))
-    console.log(pc.dim("Install from: https://bun.sh"))
-    console.log()
-    if (process.platform === "win32") {
-      console.log(pc.cyan('powershell -c "irm bun.sh/install.ps1 | iex"'))
-    } else {
-      console.log(pc.cyan("curl -fsSL https://bun.sh/install | bash"))
-    }
-    console.log()
-    process.exit(1)
-  }
-
-  if (!hasGit) {
-    console.log(pc.red("Error: Git not found."))
-    console.log(pc.dim("Install git to continue."))
-    process.exit(1)
-  }
-
-  // GitHub CLI is optional for public templates
-  // Will be checked later if user wants to create a repo
-  if (!hasGh) {
-    console.log(pc.dim("  GitHub CLI not found (repo creation will be skipped)"))
-    console.log(pc.dim("  Install from: https://cli.github.com"))
-    console.log()
-  }
-
-  // M30: Verificar/instalar Railway CLI
-  const hasRailway = await ensureRailwayCli()
-  if (hasRailway) {
-    const railwayAuth = await isRailwayAuthenticated()
-    if (!railwayAuth) {
-      console.log(pc.yellow("Railway CLI not authenticated."))
-      console.log(pc.dim("Run: railway login"))
-      console.log()
-    }
-  }
-
-  const { flags, projectName } = parseFlags(args)
-
-  p.intro(pc.bgCyan(pc.black(" New nimbuslab Project ")))
-
-  let config: ProjectConfig | symbol
-
-  // Determina tipo baseado nas flags
-  const hasTypeFlag = flags.landing || flags.app || flags.turborepo || flags.fast || flags.fastPlus || flags.fastTurborepo || flags.core
-  const typeFromFlag: ProjectType | null = flags.landing ? "landing"
-    : flags.app ? "app"
-    : flags.turborepo ? "turborepo"
-    : flags.fastTurborepo ? "fast+"
-    : flags.fastPlus ? "fast+"
-    : flags.fast ? "fast"
-    : flags.core ? "nimbus-core"
-    : null
-  const monorepoFromFlag = flags.fastTurborepo
-
-  // Modo automatico: -y com nome OU flags de tipo com nome
-  if ((flags.yes || hasTypeFlag) && projectName) {
-    // Templates públicos usam "landing" como default
-    const defaultType: ProjectType = flags.landing || flags.app || flags.turborepo ? "landing" : "fast"
-    config = {
-      name: projectName,
-      type: typeFromFlag || defaultType,
-      monorepo: monorepoFromFlag,
-      git: !flags.noGit,
-      install: !flags.noInstall,
-      github: false,
-      githubOrg: null,
-      githubDescription: "",
-      theme: "dark" as const,
-      aiAssistant: null,
-      contractNumber: "",
-      resendApiKey: "",
-      resendFromEmail: "",
-      contactEmail: "",
-      railwayProject: "",
-      railwayToken: "",
-      stagingUrl: "",
-      productionUrl: "",
-      customTemplate: flags.template,
-    }
-
-    const typeLabel = flags.turborepo ? "fast+ (monorepo)" : config.type
-    console.log(pc.dim(`  Project: ${projectName}`))
-    console.log(pc.dim(`  Type: ${typeLabel}`))
-    console.log(pc.dim(`  Git: ${config.git ? "yes" : "no"}`))
-    console.log(pc.dim(`  Install: ${config.install ? "yes" : "no"}`))
-    if (flags.railway) console.log(pc.dim(`  Railway: configurar`))
-    if (flags.template) console.log(pc.dim(`  Template: ${flags.template}`))
-    console.log()
-
-    // Railway automatico se flag --railway
-    if (flags.railway) {
-      const railwayAuthenticated = await isRailwayAuthenticated()
-      if (railwayAuthenticated) {
-        if (config.type === "fast") {
-          const projects = await listRailwayProjects()
-          const fastProject = projects.find(p => p.toLowerCase().includes("fast by nimbuslab"))
-          if (fastProject) {
-            config.railwayProject = fastProject
-            console.log(pc.green(`  Railway: ${fastProject}`))
-          }
-        } else {
-          // Fast+: cria projeto novo automaticamente
-          console.log(pc.dim(`  Creating project Railway: ${projectName}...`))
-          try {
-            const result = await $`echo "" | railway init -n ${projectName} -w nimbuslab --json`.text()
-            const newProject = JSON.parse(result)
-            config.railwayProject = newProject.name || projectName
-            console.log(pc.green(`  Railway: ${config.railwayProject} criado`))
-          } catch {
-            console.log(pc.yellow(`  Railway: erro ao criar projeto`))
-          }
-        }
-      } else {
-        console.log(pc.yellow(`  Railway: not authenticated (railway login)`))
-      }
-      console.log()
-    }
-  } else {
-    config = await promptConfig(projectName, flags)
-  }
-
-  if (p.isCancel(config)) {
-    p.cancel("Operation cancelled")
-    process.exit(0)
-  }
-
-  await createProject(config as ProjectConfig)
-
-  p.outro(pc.green("Project created successfully!"))
-
-  showNextSteps(config as ProjectConfig)
-}
-
-async function promptConfig(initialName?: string, flags?: CreateFlags): Promise<ProjectConfig | symbol> {
-  // Detectar usuario git e se é membro da nimbuslab
-  const { isMember, user } = await isNimbuslabMember()
-
-  // Saudacao
-  const greeting = user ? `Hello, ${user}!` : "Hello!"
-  console.log(pc.dim(`  ${greeting}`))
-  console.log()
-
-  const name = await p.text({
-    message: "Project name:",
-    placeholder: "meu-projeto",
-    initialValue: initialName,
-    validate: (value) => {
-      if (!value) return "Name is required"
-      if (!/^[a-z0-9-]+$/.test(value)) {
-        return "Use only lowercase letters, numbers and hyphens"
-      }
-      return undefined
-    },
-  })
-
-  if (p.isCancel(name)) return name
-
-  // Opções públicas (todos veem)
-  const publicOptions = [
-    {
-      value: "landing",
-      label: "Landing Page",
-      hint: "Next.js 16 + Tailwind 4 + shadcn",
-    },
-    {
-      value: "app",
-      label: "Web App",
-      hint: "Landing + Better Auth + Drizzle",
-    },
-    {
-      value: "turborepo",
-      label: "Monorepo",
-      hint: "Turborepo + apps/packages",
-    },
-  ]
-
-  // Opções privadas (só membros nimbuslab)
-  const privateOptions = isMember ? [
-    {
-      value: "fast",
-      label: "fast",
-      hint: "Landing page fast methodology",
-    },
-    {
-      value: "fast+",
-      label: "fast+",
-      hint: "Complete SaaS",
-    },
-    {
-      value: "nimbus-core",
-      label: "nimbus-core",
-      hint: "External projects (stealth mode)",
-    },
-  ] : []
-
-  const type = await p.select({
-    message: "Project type:",
-    options: [...publicOptions, ...privateOptions],
-  })
-
-  if (p.isCancel(type)) return type
-
-  // Verifica se é template público (não precisa de auth nimbuslab)
-  const isPublicTemplate = ["landing", "app", "turborepo"].includes(type as string)
-
-  // Se não é membro e tentou usar template privado (via flag), bloqueia
-  if (!isMember && !isPublicTemplate) {
-    console.log(pc.red("Error: Template available only for nimbuslab members"))
-    process.exit(1)
-  }
-
-  // Fluxo especial para nimbus-core (projetos externos)
-  if (type === "nimbus-core") {
-    console.log()
-    console.log(pc.dim("  nimbus-core: Motor para projetos externos (stealth mode)"))
-    console.log()
-
-    // Perguntar se quer criar repo (GitHub ou nenhum)
-    const repoOption = await p.select({
-      message: "Create repository for this project?",
-      options: [
-        { value: "github", label: "GitHub (nimbuslab, private)", hint: "recommended" },
-        { value: "none", label: "No repository", hint: "just local" },
-      ],
-    })
-    if (p.isCancel(repoOption)) return repoOption
-
-    // Perguntar URL do repo do cliente para clonar no workspace
-    const clientRepo = await p.text({
-      message: "Client repo URL (to clone in workspace):",
-      placeholder: "git@github.com:client/repo.git ou Azure DevOps URL",
-    })
-    if (p.isCancel(clientRepo)) return clientRepo
-
-    return {
-      name: name as string,
-      type: "nimbus-core" as ProjectType,
-      monorepo: false,
-      git: true, // sempre init git
-      install: false, // nimbus-core não tem package.json
-      github: repoOption === "github",
-      githubOrg: "nimbuslab", // sempre na org nimbuslab
-      githubDescription: `nimbus-core for ${name} - external project`,
-      theme: "dark" as const,
-      aiAssistant: null,
-      contractNumber: "",
-      resendApiKey: "",
-      resendFromEmail: "",
-      contactEmail: "",
-      railwayProject: "",
-      railwayToken: "",
-      stagingUrl: "",
-      productionUrl: "",
-      customTemplate: null, // não usa template customizado
-      clientRepoUrl: (clientRepo as string) || null, // URL do cliente separada
-    }
-  }
-
-  // Pergunta sobre monorepo apenas para fast+
-  let monorepo = false
-  if (type === "fast+") {
-    const useMonorepo = await p.confirm({
-      message: "Use monorepo (Turborepo)?",
-      initialValue: false,
-    })
-    if (p.isCancel(useMonorepo)) return useMonorepo
-    monorepo = useMonorepo as boolean
-  }
-
-  const git = await p.confirm({
-    message: "Initialize Git repository?",
-    initialValue: true,
-  })
-
-  if (p.isCancel(git)) return git
-
-  // GitHub options (only if git is enabled)
-  let github = false
-  let githubOrg: string | null = null
-  let githubDescription = ""
-
-  if (git) {
-    const createGithub = await p.confirm({
-      message: "Create GitHub repository?",
-      initialValue: false,
-    })
-
-    if (p.isCancel(createGithub)) return createGithub
-
-    github = createGithub as boolean
-
-    if (github) {
-      // M13: Selecao de organizacao GitHub
-      const org = await p.select({
-        message: "GitHub organization:",
-        options: [
-          { value: "nimbuslab", label: "nimbuslab", hint: "Main org" },
-          { value: "fast-by-nimbuslab", label: "fast-by-nimbuslab", hint: "Client projects" },
-          { value: "nimbuslab-templates", label: "nimbuslab-templates", hint: "Templates" },
-          { value: null, label: "Pessoal", hint: "Personal" },
-        ],
-      })
-
-      if (p.isCancel(org)) return org
-      githubOrg = org as string | null
-
-      // M14: Descricao do repo
-      const description = await p.text({
-        message: "Repository description:",
-        placeholder: "Landing page para cliente X",
-        initialValue: type === "fast" ? "Landing page fast by nimbuslab" : "SaaS fast+ by nimbuslab",
-      })
-
-      if (p.isCancel(description)) return description
-      githubDescription = description as string
-    }
-  }
-
-  // M26: Número do contrato (apenas para fast - privado)
-  let contractNumber = ""
-  if (type === "fast") {
-    const contract = await p.text({
-      message: "Contract number (ex: 001):",
-      placeholder: "001",
-      validate: (v) => v ? undefined : "Contract number is required for fast",
-    })
-    if (p.isCancel(contract)) return contract
-    contractNumber = contract as string
-  }
-
-  // Templates públicos têm fluxo simplificado mas com configs globais
-  if (isPublicTemplate) {
-    // Theme selection
-    const theme = await p.select({
-      message: "Default theme:",
-      options: [
-        { value: "dark", label: "Dark", hint: "recommended" },
-        { value: "light", label: "Light" },
-        { value: "system", label: "System", hint: "follows OS preference" },
-      ],
-    })
-    if (p.isCancel(theme)) return theme
-
-    // AI Assistant selection
-    const aiAssistant = await p.select({
-      message: "Which AI assistant do you use?",
-      options: [
-        { value: "claude", label: "Claude Code", hint: "Anthropic" },
-        { value: "cursor", label: "Cursor", hint: "AI-first editor" },
-        { value: "gemini", label: "Gemini CLI", hint: "Google" },
-        { value: "copilot", label: "GitHub Copilot" },
-        { value: "windsurf", label: "Windsurf", hint: "Codeium" },
-        { value: "none", label: "None", hint: "skip AI config" },
-      ],
-    })
-    if (p.isCancel(aiAssistant)) return aiAssistant
-
-    // GitHub repo for public templates (uses user's orgs)
-    let publicGithub = false
-    let publicGithubOrg: string | null = null
-
-    if (git) {
-      const gh = await checkGitHubCli()
-
-      if (gh.installed && gh.authenticated) {
-        const createRepo = await p.confirm({
-          message: "Create GitHub repository?",
-          initialValue: false,
-        })
-        if (p.isCancel(createRepo)) return createRepo
-
-        publicGithub = createRepo as boolean
-
-        if (publicGithub) {
-          const repoOptions: { value: string | null; label: string; hint?: string }[] = [
-            { value: gh.username, label: gh.username!, hint: "personal account" },
-            ...gh.orgs.map((org) => ({ value: org, label: org })),
-          ]
-
-          const repoOwner = await p.select({
-            message: "Where to create the repository?",
-            options: repoOptions,
-          })
-          if (p.isCancel(repoOwner)) return repoOwner
-          publicGithubOrg = repoOwner as string | null
-
-          const repoVisibility = await p.select({
-            message: "Repository visibility:",
-            options: [
-              { value: "private", label: "Private", hint: "recommended" },
-              { value: "public", label: "Public" },
-            ],
-          })
-          if (p.isCancel(repoVisibility)) return repoVisibility
-          githubDescription = repoVisibility as string // reusing for visibility
-        }
-      }
-    }
-
-    const install = await p.confirm({
-      message: "Install dependencies?",
-      initialValue: true,
-    })
-
-    if (p.isCancel(install)) return install
-
-    return {
-      name: name as string,
-      type: type as ProjectType,
-      monorepo: false,
-      git: git as boolean,
-      install: install as boolean,
-      github: publicGithub,
-      githubOrg: publicGithubOrg,
-      githubDescription,
-      theme: theme as "dark" | "light" | "system",
-      aiAssistant: aiAssistant === "none" ? null : aiAssistant as string,
-      contractNumber: "",
-      resendApiKey: "",
-      resendFromEmail: "",
-      contactEmail: "",
-      railwayProject: "",
-      railwayToken: "",
-      stagingUrl: "",
-      productionUrl: "",
-      customTemplate: flags?.template || null,
-    }
-  }
-
-  // Configuracoes de infra (separadas)
-  let resendApiKey = ""
-  let resendFromEmail = ""
-  let contactEmail = ""
-  let railwayProject = ""
-  let railwayToken = ""
-  let stagingUrl = ""
-  let productionUrl = ""
-
-  const currentYear = new Date().getFullYear().toString().slice(-3) // 025, 026, etc
-
-  // Defaults
-  const defaultStagingUrl = type === "fast"
-    ? `https://fast-${contractNumber}-${currentYear}.nimbuslab.net.br`
-    : `https://${name}.nimbuslab.net.br`
-  const defaultFromEmail = "no-reply@nimbuslab.com.br"
-  const defaultContactEmail = type === "fast"
-    ? "fast@nimbuslab.com.br"
-    : "suporte@nimbuslab.com.br"
-
-  // Menu de configuracoes opcionais
-  const infraOptions = await p.multiselect({
-    message: "What do you want to configure now?",
-    options: [
-      { value: "urls", label: "URLs", hint: "staging and production" },
-      { value: "resend", label: "Resend", hint: "form emails" },
-      { value: "railway", label: "Railway", hint: "deploy and hosting" },
-    ],
-    required: false,
-  })
-
-  if (p.isCancel(infraOptions)) return infraOptions
-
-  const configItems = infraOptions as string[]
-
-  // URLs
-  if (configItems.includes("urls")) {
-    console.log()
-    console.log(pc.dim("  Project URLs"))
-
-    const staging = await p.text({
-      message: "Staging URL:",
-      placeholder: defaultStagingUrl,
-      initialValue: defaultStagingUrl,
-    })
-    if (p.isCancel(staging)) return staging
-    stagingUrl = staging as string
-
-    const production = await p.text({
-      message: "Production URL:",
-      placeholder: defaultStagingUrl.replace('.nimbuslab.net.br', '.com.br'),
-      initialValue: "",
-    })
-    if (p.isCancel(production)) return production
-    productionUrl = production as string
-  }
-
-  // Resend
-  if (configItems.includes("resend")) {
-    console.log()
-    console.log(pc.dim("  Resend (Email)"))
-
-    const resendKey = await p.text({
-      message: "RESEND_API_KEY:",
-      placeholder: "re_xxxxxxxxxxxx",
-    })
-    if (p.isCancel(resendKey)) return resendKey
-    resendApiKey = resendKey as string
-
-    const fromEmail = await p.text({
-      message: "From email:",
-      placeholder: defaultFromEmail,
-      initialValue: defaultFromEmail,
-    })
-    if (p.isCancel(fromEmail)) return fromEmail
-    resendFromEmail = fromEmail as string
-
-    const contact = await p.text({
-      message: "Contact email (receives forms):",
-      placeholder: defaultContactEmail,
-      initialValue: defaultContactEmail,
-    })
-    if (p.isCancel(contact)) return contact
-    contactEmail = contact as string
-  }
-
-  // Railway
-  if (configItems.includes("railway")) {
-    // M30: Railway via CLI
-    const railwayAuthenticated = await isRailwayAuthenticated()
-
-    if (railwayAuthenticated) {
-      console.log()
-      console.log(pc.dim("  Railway"))
-
-      const projects = await listRailwayProjects()
-
-      if (type === "fast") {
-        // Fast usa projeto compartilhado "Fast by nimbuslab"
-        const fastProject = projects.find(p => p.toLowerCase().includes("fast by nimbuslab"))
-        if (fastProject) {
-          railwayProject = fastProject
-          console.log(pc.green(`  Project: ${fastProject} (automatico)`))
-        } else {
-          console.log(pc.yellow("  Project 'Fast by nimbuslab' not found."))
-          console.log(pc.dim("  Configure manually in .env"))
-        }
-      } else {
-        // Fast+ pode escolher projeto existente ou criar novo
-        const projectOptions = [
-          ...projects.map(proj => ({ value: proj, label: proj })),
-          { value: "__new__", label: "Create new project", hint: "via railway init" },
-          { value: "__skip__", label: "Skip", hint: "Configure later" },
-        ]
-
-        const selectedProject = await p.select({
-          message: "Railway project for this SaaS:",
-          options: projectOptions,
-        })
-
-        if (p.isCancel(selectedProject)) return selectedProject
-
-        if (selectedProject === "__new__") {
-          // Criar projeto via Railway CLI
-          const projectNameForRailway = name as string
-          console.log(pc.dim(`  Creating project "${projectNameForRailway}" on Railway...`))
-          try {
-            // Usa echo para passar input vazio e aceitar defaults (workspace)
-            const result = await $`echo "" | railway init -n ${projectNameForRailway} -w nimbuslab --json`.text()
-            const newProject = JSON.parse(result)
-            railwayProject = newProject.name || projectNameForRailway
-            console.log(pc.green(`  Projeto "${railwayProject}" created successfully!`))
-            console.log(pc.dim(`  ID: ${newProject.id || "N/A"}`))
-          } catch (error) {
-            console.log(pc.yellow("  Error creating project via CLI."))
-            console.log(pc.dim("  Create manually at: https://railway.app/new"))
-          }
-        } else if (selectedProject !== "__skip__") {
-          railwayProject = selectedProject as string
-          console.log(pc.green(`  Project selected: ${railwayProject}`))
-        }
-      }
-    } else {
-      console.log()
-      console.log(pc.yellow("  Railway: not authenticated (railway login)"))
-      console.log(pc.dim("  Configure manually in .env"))
-    }
-  }
-
-  const install = await p.confirm({
-    message: "Install dependencies?",
-    initialValue: true,
-  })
-
-  if (p.isCancel(install)) return install
-
-  return {
-    name: name as string,
-    type: type as "fast" | "fast+",
-    monorepo,
-    git: git as boolean,
-    install: install as boolean,
-    github,
-    githubOrg,
-    githubDescription,
-    theme: "dark" as const,
-    aiAssistant: null,
-    contractNumber,
-    resendApiKey,
-    resendFromEmail,
-    contactEmail,
-    railwayProject,
-    railwayToken,
-    stagingUrl,
-    productionUrl,
-    customTemplate: flags?.template || null,
-  }
-}
-
-async function createProject(config: ProjectConfig) {
-  const s = p.spinner()
-
-  // Determina template: customizado ou padrao
-  let templateRepo: string
-  let templateLabel: string
-
-  if (config.customTemplate) {
-    templateRepo = config.customTemplate
-    templateLabel = `customizado (${config.customTemplate})`
-  } else {
-    // fast+ com monorepo usa template específico
-    const templateKey = config.type === "fast+" && config.monorepo ? "fast+-monorepo" : config.type
-    templateRepo = TEMPLATES[templateKey as keyof typeof TEMPLATES]
-    templateLabel = config.monorepo ? `${config.type} (monorepo)` : config.type
-  }
-
-  // Verifica se é template público
-  const isPublicTemplate = ["landing", "app", "turborepo"].includes(config.type)
-
-  s.start(`Cloning template ${templateLabel}...`)
-  try {
-    if (isPublicTemplate) {
-      // Templates públicos: usa HTTPS (não precisa de auth)
-      const httpsUrl = `https://github.com/${templateRepo}.git`
-      await $`git clone --depth 1 ${httpsUrl} ${config.name}`.quiet()
-    } else {
-      // Templates privados: usa gh (precisa de auth)
-      await $`gh repo clone ${templateRepo} ${config.name} -- --depth 1`.quiet()
-    }
-    await rm(join(config.name, ".git"), { recursive: true, force: true })
-    s.stop(`Template cloned`)
-  } catch (error) {
-    s.stop("Error cloning template")
-    throw new Error(`Failed to clone template ${templateRepo}. Check your connection or repository access.`)
-  }
-
-  // nimbus-core: clone client repo in workspace if provided
-  if (config.type === "nimbus-core" && config.clientRepoUrl) {
-    const clientRepoUrl = config.clientRepoUrl
-    s.start(`Cloning client repo in workspace...`)
-    try {
-      // Extrair nome do projeto da URL (funciona com GitHub, GitLab, Azure DevOps)
-      let projectName = "client-project"
-      if (clientRepoUrl.includes("visualstudio.com") || clientRepoUrl.includes("dev.azure.com")) {
-        // Azure DevOps: serel@vs-ssh.visualstudio.com:v3/serel/Project/Repo
-        const parts = clientRepoUrl.split("/")
-        projectName = parts[parts.length - 1] || "client-project"
-      } else {
-        // GitHub/GitLab: git@github.com:org/repo.git
-        projectName = clientRepoUrl.split("/").pop()?.replace(".git", "") || "client-project"
-      }
-      await $`git clone ${clientRepoUrl} ${config.name}/workspace/${projectName}`.quiet()
-      s.stop(`Client repo cloned: workspace/${projectName}`)
-    } catch (error) {
-      s.stop("Error cloning client repo")
-      console.log(pc.dim("  You can clone manually: cd workspace && git clone <url>"))
-    }
-  }
-
-  // Update package.json (skip for nimbus-core)
-  if (config.type !== "nimbus-core") {
-    s.start("Configuring project...")
-    try {
-      const pkgPath = `${config.name}/package.json`
-      const pkg = await Bun.file(pkgPath).json()
-      pkg.name = config.name
-      await Bun.write(pkgPath, JSON.stringify(pkg, null, 2))
-      s.stop("Project configured")
-    } catch (error) {
-      s.stop("Error configuring")
-      // Continue anyway
-    }
-  }
-
-  // Apply theme config (public templates only)
-  if (isPublicTemplate && config.theme) {
-    s.start(`Setting theme to ${config.theme}...`)
-    try {
-      const layoutPath = `${config.name}/src/app/layout.tsx`
-      let layout = await Bun.file(layoutPath).text()
-      layout = layout.replace(
-        /defaultTheme="(dark|light|system)"/,
-        `defaultTheme="${config.theme}"`
-      )
-      await Bun.write(layoutPath, layout)
-      s.stop(`Theme set to ${config.theme}`)
-    } catch {
-      s.stop("Theme config skipped")
-    }
-  }
-
-  // Generate AI config (public templates only)
-  if (isPublicTemplate && config.aiAssistant) {
-    const aiConfig = AI_CONFIGS[config.aiAssistant]
-    if (aiConfig) {
-      s.start(`Generating ${config.aiAssistant} config...`)
-      try {
-        const content = aiConfig.content(config.type)
-        const filePath = `${config.name}/${aiConfig.filename}`
-
-        // Create directory if needed
-        if (aiConfig.filename.includes("/")) {
-          const dir = aiConfig.filename.split("/").slice(0, -1).join("/")
-          await mkdir(`${config.name}/${dir}`, { recursive: true })
-        }
-
-        await Bun.write(filePath, content)
-        s.stop(`${aiConfig.filename} created`)
-      } catch {
-        s.stop("AI config skipped")
-      }
-    }
-  }
-
-  // Setup fast+ if selected
-  if (config.type === "fast+") {
-    s.start("Configurando fast+ (SaaS)...")
-    // O setup real será feito pelo bun setup do próprio template
-    s.stop("Configuracao fast+ preparada")
-  }
-
-  // Git init with full branch flow: main → staging → develop
-  if (config.git) {
-    s.start("Initializing Git...")
-    try {
-      const cwd = config.name
-      // Init with main branch (not master)
-      await $`git init -b main`.cwd(cwd).quiet()
-      await $`git add -A`.cwd(cwd).quiet()
-      await $`git commit -m "chore: setup inicial via nimbus create"`.cwd(cwd).quiet()
-
-      // Create branch flow: main → staging → develop
-      await $`git checkout -b staging`.cwd(cwd).quiet()
-      await $`git checkout -b develop`.cwd(cwd).quiet()
-
-      s.stop("Git initialized (main -> staging -> develop)")
-    } catch (error) {
-      s.stop("Error initializing Git")
-    }
-
-    // Create GitHub repo if requested (M13 + M14)
-    if (config.github) {
-      s.start("Creating GitHub repository...")
-      try {
-        const cwd = config.name
-        const repoName = config.githubOrg
-          ? `${config.githubOrg}/${config.name}`
-          : config.name
-
-        // For public templates, githubDescription contains visibility (private/public)
-        // For private templates, use org-based visibility
-        // nimbus-core is ALWAYS private
-        let visibility: string
-        if (config.type === "nimbus-core") {
-          visibility = "--private" // nimbus-core sempre privado
-        } else if (isPublicTemplate) {
-          visibility = config.githubDescription === "public" ? "--public" : "--private"
-        } else {
-          visibility = config.githubOrg === "fast-by-nimbuslab" ? "--private" : "--public"
-        }
-
-        // Create repo
-        if (isPublicTemplate) {
-          await $`gh repo create ${repoName} ${visibility} --source . --remote origin`.cwd(cwd).quiet()
-        } else {
-          await $`gh repo create ${repoName} ${visibility} --description ${config.githubDescription} --source . --remote origin`.cwd(cwd).quiet()
-        }
-
-        // Push todas as branches na ordem correta: main -> staging -> develop
-        await $`git checkout main`.cwd(cwd).quiet()
-        await $`git push -u origin main`.cwd(cwd).quiet()
-        await $`git checkout staging`.cwd(cwd).quiet()
-        await $`git push -u origin staging`.cwd(cwd).quiet()
-        await $`git checkout develop`.cwd(cwd).quiet()
-        await $`git push -u origin develop`.cwd(cwd).quiet()
-
-        s.stop(`GitHub: ${repoName}`)
-      } catch (error) {
-        s.stop("Error creating GitHub repository")
-        console.log(pc.dim("  You can create manually with: gh repo create"))
-      }
-    }
-  }
-
-  // Railway link (se projeto foi selecionado/criado)
-  if (config.railwayProject) {
-    s.start(`Linkando Railway: ${config.railwayProject}...`)
-    try {
-      await $`railway link -p ${config.railwayProject}`.cwd(config.name).quiet()
-      s.stop(`Railway linkado: ${config.railwayProject}`)
-    } catch (error) {
-      s.stop("Error linking Railway")
-      console.log(pc.dim("  Run manually: railway link"))
-    }
-  }
-
-  // M23: Gerar .env se configs foram fornecidas
-  if (config.resendApiKey || config.stagingUrl) {
-    s.start("Gerando arquivo .env...")
-    try {
-      const envContent = generateEnvFile(config)
-      await Bun.write(`${config.name}/.env`, envContent)
-      s.stop("Arquivo .env criado")
-    } catch (error) {
-      s.stop("Error creating .env")
-    }
-  }
-
-  // Install deps
-  if (config.install) {
-    s.start("Installing dependencies (pode demorar)...")
-    try {
-      await $`bun install`.cwd(config.name).quiet()
-      s.stop("Dependencies installed")
-    } catch (error) {
-      s.stop("Error installing dependencies")
-    }
-  }
-}
-
-// M23: Gerar conteudo do .env
-function generateEnvFile(config: ProjectConfig): string {
-  const lines = [
-    "# Gerado automaticamente pelo nimbus-cli",
-    "# Nao commitar este arquivo!",
-    "",
-    "# App",
-    `NODE_ENV=development`,
-    "",
-    "# URLs",
-    `NEXT_PUBLIC_APP_URL=${config.productionUrl || "http://localhost:3000"}`,
-    `STAGING_URL=${config.stagingUrl || ""}`,
-    `PRODUCTION_URL=${config.productionUrl || ""}`,
-    "",
-    "# Resend (Email)",
-    `RESEND_API_KEY=${config.resendApiKey || ""}`,
-    `RESEND_FROM_EMAIL=${config.resendFromEmail || ""}`,
-    `CONTACT_EMAIL=${config.contactEmail || ""}`,
-  ]
-
-  // Railway (projeto e token)
-  if (config.railwayProject || config.railwayToken) {
-    lines.push("")
-    lines.push("# Railway")
-    if (config.railwayProject) {
-      lines.push(`# Project: ${config.railwayProject}`)
-    }
-    lines.push(`RAILWAY_TOKEN=${config.railwayToken || "# Configure com: railway link"}`)
-  }
-
-  // Fast+ specific vars
-  if (config.type === "fast+") {
-    lines.push("")
-    lines.push("# Database (fast+)")
-    lines.push("DATABASE_URL=postgresql://postgres:postgres@localhost:5432/app")
-    lines.push("")
-    lines.push("# Auth (fast+)")
-    lines.push("BETTER_AUTH_SECRET=")
-    lines.push("BETTER_AUTH_URL=http://localhost:3000")
-  }
-
-  return lines.join("\n") + "\n"
-}
-
-function showNextSteps(config: ProjectConfig) {
-  const isPublicTemplate = ["landing", "app", "turborepo"].includes(config.type)
-  const needsSetup = config.type === "app" // app needs bun setup for DB
-
-  console.log()
-  console.log(pc.bold("Next steps:"))
-  console.log()
-  console.log(`  ${pc.cyan("cd")} ${config.name}`)
-
-  // nimbus-core tem fluxo especial
-  if (config.type === "nimbus-core") {
-    console.log()
-    console.log(pc.dim("  nimbus-core: Motor para projetos externos"))
-    console.log()
-    console.log(pc.dim("  Para usar a Lola:"))
-    console.log(`    ${pc.cyan("lola")}`)
-    console.log()
-    console.log(pc.yellow("  STEALTH MODE: Commits sem mencao a nimbuslab/Lola/IA"))
-    console.log()
-
-    // GitHub info
-    if (config.github) {
-      const repoUrl = `https://github.com/nimbuslab/${config.name}`
-      console.log(pc.green(`  GitHub (private): ${repoUrl}`))
-      console.log()
-    }
-
-    console.log(pc.dim("  Docs: See README.md for full instructions"))
-    console.log()
-    return
-  }
-
-  if (!config.install) {
-    console.log(`  ${pc.cyan("bun")} install`)
-  }
-
-  // Templates que precisam de setup adicional
-  if (!isPublicTemplate || needsSetup) {
-    console.log(`  ${pc.cyan("bun")} setup`)
-  }
-
-  console.log(`  ${pc.cyan("bun")} dev`)
-  console.log()
-
-  // Explicar o que o bun setup faz para o app
-  if (needsSetup && isPublicTemplate) {
-    console.log(pc.dim("  bun setup will:"))
-    console.log(pc.dim("    - Start PostgreSQL with Docker"))
-    console.log(pc.dim("    - Run database migrations"))
-    console.log(pc.dim("    - Create demo user (demo@example.com / demo1234)"))
-    console.log()
-  }
-
-  // Git flow info
-  if (config.git) {
-    console.log(pc.dim("  Git: main -> staging -> develop (current branch)"))
-
-    // GitHub info
-    if (config.github) {
-      const repoUrl = config.githubOrg
-        ? `https://github.com/${config.githubOrg}/${config.name}`
-        : `https://github.com/${config.name}`
-      console.log(pc.green(`  GitHub: ${repoUrl}`))
-    }
-    console.log()
-  }
-
-  // Theme e AI info
-  if (isPublicTemplate) {
-    if (config.theme !== "dark") {
-      console.log(pc.dim(`  Theme: ${config.theme}`))
-    }
-    if (config.aiAssistant) {
-      const aiConfig = AI_CONFIGS[config.aiAssistant]
-      if (aiConfig) {
-        console.log(pc.dim(`  AI config: ${aiConfig.filename}`))
-      }
-    }
-    if (config.theme !== "dark" || config.aiAssistant) {
-      console.log()
-    }
-  }
-
-  if (config.type === "fast+") {
-    console.log(pc.dim("  bun setup will:"))
-    console.log(pc.dim("    - Start PostgreSQL with Docker"))
-    console.log(pc.dim("    - Run database migrations"))
-    console.log(pc.dim("    - Create demo user (demo@example.com / demo1234)"))
-    console.log()
-    console.log(pc.dim("  Tip: Configure DATABASE_URL and BETTER_AUTH_SECRET in .env"))
-    if (!config.railwayToken) {
-      console.log(pc.dim("  Railway: Create a project at https://railway.app/new"))
-    }
-    console.log()
-  }
-
-  // Info sobre .env (templates privados)
-  if (!isPublicTemplate) {
-    if (config.resendApiKey || config.stagingUrl) {
-      console.log(pc.green("  .env configured!"))
-      console.log()
-    } else {
-      console.log(pc.yellow("  Tip: Configure .env manually or use 'bun setup'."))
-      console.log()
-    }
-  }
-
-  // Info sobre templates
-  if (isPublicTemplate) {
-    console.log(pc.dim("  Open source template (MIT) by nimbuslab"))
-    console.log(pc.dim(`  https://github.com/nimbuslab/create-next-${config.type === "turborepo" ? "turborepo" : config.type}`))
-  } else {
-    console.log(pc.dim("  https://github.com/nimbuslab-templates"))
-  }
-  console.log()
-}