@nimbuslab/cli 0.16.4 → 0.16.5

package/src/commands/update.ts

@@ -1,334 +0,0 @@
-import * as p from "@clack/prompts"
-import pc from "picocolors"
-import { execSync, spawnSync } from "child_process"
-
-const PACKAGE_NAME = "@nimbuslab/cli"
-
-type PackageManager = "bun" | "npm" | "unknown"
-
-// Verifica se existe instalacao no bun global
-function hasBunInstall(): boolean {
-  try {
-    const result = spawnSync("bun", ["pm", "ls", "-g"], {
-      encoding: "utf-8",
-      shell: true,
-      timeout: 5000,
-    })
-    return !!(result.stdout && result.stdout.includes(PACKAGE_NAME))
-  } catch {
-    return false
-  }
-}
-
-// Verifica se existe instalacao no npm global
-function hasNpmInstall(): boolean {
-  try {
-    const result = spawnSync("npm", ["ls", "-g", PACKAGE_NAME, "--json"], {
-      encoding: "utf-8",
-      shell: true,
-      timeout: 5000,
-    })
-    if (result.stdout) {
-      const data = JSON.parse(result.stdout)
-      return !!data.dependencies?.[PACKAGE_NAME]
-    }
-  } catch {
-    // ignore
-  }
-  return false
-}
-
-// Remove instalacao duplicada para evitar conflitos
-// Prioriza npm (fnm/nvm), remove bun se tiver npm
-function cleanupDuplicateInstalls(): { cleaned: boolean; message: string } {
-  const hasNpm = hasNpmInstall()
-  const hasBun = hasBunInstall()
-
-  if (hasNpm && hasBun) {
-    // Tem nos dois - remover do bun (prioriza npm)
-    try {
-      execSync("bun remove -g @nimbuslab/cli", { stdio: "pipe", encoding: "utf-8" })
-      return {
-        cleaned: true,
-        message: "Instalacao duplicada removida do bun (usando npm)",
-      }
-    } catch {
-      return {
-        cleaned: false,
-        message: "Falha ao remover instalacao duplicada do bun",
-      }
-    }
-  }
-
-  return { cleaned: false, message: "" }
-}
-
-// Detecta se está usando fnm (Fast Node Manager)
-function isUsingFnm(): boolean {
-  const fnmDir = process.env.FNM_DIR || process.env.FNM_MULTISHELL_PATH
-  const checkCmd = process.platform === "win32" ? "where" : "which"
-  const whichNode = spawnSync(checkCmd, ["node"], { encoding: "utf-8", shell: true })
-  return !!(fnmDir || (whichNode.stdout && whichNode.stdout.includes("fnm")))
-}
-
-async function getAvailableVersions(): Promise<string[]> {
-  try {
-    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}`)
-    if (!res.ok) return []
-    const data = await res.json() as { versions?: Record<string, unknown> }
-    return Object.keys(data.versions || {}).reverse()
-  } catch {
-    return []
-  }
-}
-
-async function getLatestVersion(): Promise<string | null> {
-  try {
-    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`)
-    if (!res.ok) return null
-    const data = await res.json() as { version?: string }
-    return data.version || null
-  } catch {
-    return null
-  }
-}
-
-// Detecta qual package manager tem o pacote instalado globalmente
-// Prioriza npm (mais comum com fnm/nvm)
-function detectPackageManager(): PackageManager {
-  // Tentar npm primeiro (prioridade)
-  try {
-    const npmResult = spawnSync("npm", ["ls", "-g", PACKAGE_NAME, "--json"], {
-      encoding: "utf-8",
-      shell: true,
-      timeout: 5000,
-    })
-    if (npmResult.stdout) {
-      const data = JSON.parse(npmResult.stdout)
-      if (data.dependencies?.[PACKAGE_NAME]) {
-        return "npm"
-      }
-    }
-  } catch {
-    // ignore
-  }
-
-  // Fallback para bun
-  try {
-    const bunResult = spawnSync("bun", ["pm", "ls", "-g"], {
-      encoding: "utf-8",
-      shell: true,
-      timeout: 5000,
-    })
-    if (bunResult.stdout && bunResult.stdout.includes(PACKAGE_NAME)) {
-      return "bun"
-    }
-  } catch {
-    // ignore
-  }
-
-  return "unknown"
-}
-
-function getCurrentVersion(): string {
-  // Tentar npm primeiro (prioridade)
-  try {
-    const result = spawnSync("npm", ["ls", "-g", PACKAGE_NAME, "--json"], {
-      encoding: "utf-8",
-      shell: true,
-      timeout: 5000,
-    })
-    if (result.stdout) {
-      const data = JSON.parse(result.stdout)
-      if (data.dependencies?.[PACKAGE_NAME]?.version) {
-        return data.dependencies[PACKAGE_NAME].version
-      }
-    }
-  } catch {
-    // ignore
-  }
-
-  // Fallback para bun
-  try {
-    const bunResult = spawnSync("bun", ["pm", "ls", "-g"], {
-      encoding: "utf-8",
-      shell: true,
-      timeout: 5000,
-    })
-    if (bunResult.stdout) {
-      // Formato: "@nimbuslab/cli@0.14.0"
-      const match = bunResult.stdout.match(new RegExp(`${PACKAGE_NAME.replace("/", "\\/")}@([\\d.]+)`))
-      if (match?.[1]) {
-        return match[1]
-      }
-    }
-  } catch {
-    // ignore
-  }
-
-  return "unknown"
-}
-
-export async function update(args: string[]) {
-  // Parse flags
-  const forceFlag = args.includes("--force") || args.includes("-f")
-  const filteredArgs = args.filter(a => a !== "--force" && a !== "-f")
-  const flag = filteredArgs[0]
-
-  // nimbus update --list
-  if (flag === "--list" || flag === "-l") {
-    p.intro(pc.cyan("Versoes disponiveis"))
-
-    const spinner = p.spinner()
-    spinner.start("Buscando versoes...")
-
-    const versions = await getAvailableVersions()
-    spinner.stop("Versoes encontradas")
-
-    if (versions.length === 0) {
-      p.log.error("Nao foi possivel buscar as versoes")
-      return
-    }
-
-    const current = getCurrentVersion()
-    const pm = detectPackageManager()
-
-    console.log()
-    console.log(pc.bold("Ultimas 10 versoes:"))
-    versions.slice(0, 10).forEach((v, i) => {
-      const isCurrent = v === current
-      const prefix = isCurrent ? pc.green("-> ") : "   "
-      const suffix = isCurrent ? pc.dim(" (instalada)") : ""
-      const isLatest = i === 0 ? pc.yellow(" (latest)") : ""
-      console.log(`${prefix}${v}${suffix}${isLatest}`)
-    })
-    console.log()
-    console.log(pc.dim(`Total: ${versions.length} versoes`))
-    console.log(pc.dim(`Package manager detectado: ${pm === "unknown" ? "nenhum" : pm}`))
-    console.log(pc.dim(`Instalar versao especifica: nimbus update <versao>`))
-    console.log(pc.dim(`Forcar reinstalacao: nimbus update --force`))
-    return
-  }
-
-  // nimbus update [version]
-  const targetVersion = flag || "latest"
-  const isSpecificVersion = flag && flag !== "latest" && !flag.startsWith("-")
-
-  p.intro(pc.cyan(`Atualizando ${PACKAGE_NAME}`))
-
-  const spinner = p.spinner()
-
-  // Limpar instalacoes duplicadas automaticamente
-  spinner.start("Verificando instalacoes...")
-  const cleanup = cleanupDuplicateInstalls()
-  if (cleanup.cleaned) {
-    spinner.stop(pc.yellow(cleanup.message))
-  } else {
-    spinner.stop("OK")
-  }
-
-  // Detectar package manager
-  spinner.start("Detectando package manager...")
-  const detectedPm = detectPackageManager()
-  // Usar npm como padrao se nenhum detectado (compativel com fnm/nvm)
-  const pm = detectedPm === "unknown" ? "npm" : detectedPm
-  spinner.stop(`Package manager: ${pm}${detectedPm === "unknown" ? " (padrao)" : ""}`)
-
-  // Verificar versao atual
-  spinner.start("Verificando versao atual...")
-  const currentVersion = getCurrentVersion()
-  spinner.stop(`Versao atual: ${currentVersion === "unknown" ? "nao instalado" : currentVersion}`)
-
-  // Verificar versao alvo
-  let latestVersion: string | null = null
-  if (!isSpecificVersion) {
-    spinner.start("Verificando ultima versao no npm...")
-    latestVersion = await getLatestVersion()
-    spinner.stop(`Ultima versao: ${latestVersion || "desconhecida"}`)
-
-    if (!forceFlag && latestVersion && latestVersion === currentVersion) {
-      p.log.success("Voce ja esta na ultima versao!")
-      console.log(pc.dim("  Use --force para reinstalar"))
-      return
-    }
-  }
-
-  // Confirmar
-  const versionText = isSpecificVersion ? targetVersion : (latestVersion || "latest")
-  const actionText = forceFlag ? "Reinstalar" : "Atualizar"
-  const confirmUpdate = await p.confirm({
-    message: `${actionText} para ${versionText} usando ${pm}?`,
-    initialValue: true,
-  })
-
-  if (p.isCancel(confirmUpdate) || !confirmUpdate) {
-    p.cancel("Atualizacao cancelada")
-    return
-  }
-
-  // Executar update
-  spinner.start("Atualizando...")
-
-  try {
-    const packageSpec = isSpecificVersion
-      ? `${PACKAGE_NAME}@${targetVersion}`
-      : latestVersion
-        ? `${PACKAGE_NAME}@${latestVersion}`
-        : PACKAGE_NAME
-
-    // Usar o package manager detectado
-    if (pm === "bun") {
-      // Bun: remover primeiro se --force, depois instalar
-      if (forceFlag) {
-        try {
-          execSync(`bun remove -g ${PACKAGE_NAME}`, { stdio: "pipe", encoding: "utf-8" })
-        } catch {
-          // ignore - pode nao estar instalado
-        }
-      }
-      execSync(`bun add -g ${packageSpec}`, { stdio: "pipe", encoding: "utf-8" })
-    } else {
-      // npm: usar --force se solicitado
-      const forceArg = forceFlag ? " --force" : ""
-      execSync(`npm install -g ${packageSpec}${forceArg}`, { stdio: "pipe", encoding: "utf-8" })
-    }
-
-    spinner.stop("Atualizacao concluida!")
-
-    // Verificar nova versao
-    const newVersion = getCurrentVersion()
-
-    if (currentVersion === newVersion && !forceFlag) {
-      p.log.warn("Versao nao mudou. Tente com --force")
-    } else {
-      p.log.success(`${PACKAGE_NAME} atualizado: ${currentVersion} -> ${newVersion}`)
-    }
-
-    // Se usa fnm, avisar sobre hash
-    if (isUsingFnm()) {
-      console.log()
-      console.log(pc.yellow("  fnm detectado - execute para aplicar:"))
-      console.log(pc.cyan("    hash -r"))
-      console.log(pc.dim("  Ou abra um novo terminal."))
-    }
-
-    p.outro(pc.green("Pronto!"))
-  } catch (error) {
-    spinner.stop("Erro na atualizacao")
-
-    const err = error as Error & { stderr?: string }
-    p.log.error("Falha ao atualizar")
-
-    if (err.stderr) {
-      console.log(pc.dim(err.stderr))
-    }
-
-    console.log()
-    console.log(pc.yellow("Tente manualmente:"))
-    if (pm === "bun") {
-      console.log(pc.cyan(`  bun add -g ${PACKAGE_NAME}${isSpecificVersion ? `@${targetVersion}` : ""}`))
-    } else {
-      console.log(pc.cyan(`  npm install -g ${PACKAGE_NAME}${isSpecificVersion ? `@${targetVersion}` : ""}`))
-    }
-  }
-}

package/src/commands/upgrade.ts

@@ -1,251 +0,0 @@
-import * as p from "@clack/prompts"
-import pc from "picocolors"
-import { analyze } from "./analyze"
-
-interface UpgradePlan {
-  current: string
-  target: string
-  breakingChanges: string[]
-  steps: string[]
-  complexity: "low" | "medium" | "high"
-}
-
-const UPGRADE_PLANS: Record<string, (currentVersion: string) => UpgradePlan | null> = {
-  next: (current) => {
-    const major = parseInt(current.replace(/[^0-9]/g, "").slice(0, 2))
-    if (major >= 16) return null
-
-    return {
-      current: current,
-      target: "16.x",
-      complexity: major < 15 ? "high" : "medium",
-      breakingChanges: [
-        "next/image: Mudancas na API de otimizacao",
-        "Middleware: Novo formato de config",
-        "next.config: Algumas opcoes depreciadas",
-        "Turbopack: Agora e o bundler padrao",
-      ],
-      steps: [
-        "Atualizar next para ^16.0.0",
-        "Atualizar react para ^19.0.0",
-        "Atualizar react-dom para ^19.0.0",
-        "Revisar next.config.ts",
-        "Testar build: bun run build",
-        "Testar dev: bun dev",
-      ],
-    }
-  },
-
-  react: (current) => {
-    if (current.startsWith("19") || current.startsWith("^19")) return null
-
-    return {
-      current: current,
-      target: "19.x",
-      complexity: "medium",
-      breakingChanges: [
-        "forwardRef: Nao mais necessario, ref e prop regular",
-        "useContext: Pode ser substituido por use(Context)",
-        "Suspense: Mudancas em fallback behavior",
-        "Async components: Novo suporte nativo",
-      ],
-      steps: [
-        "Atualizar react para ^19.0.0",
-        "Atualizar react-dom para ^19.0.0",
-        "Atualizar @types/react para ^19.0.0",
-        "Remover forwardRef (usar ref como prop)",
-        "Revisar Suspense boundaries",
-        "Testar todos os componentes",
-      ],
-    }
-  },
-
-  tailwind: (current) => {
-    if (current.startsWith("4") || current.startsWith("^4")) return null
-
-    return {
-      current: current,
-      target: "4.x",
-      complexity: "medium",
-      breakingChanges: [
-        "Config: Agora e CSS-first (nao mais tailwind.config.js)",
-        "@apply: Sintaxe mudou",
-        "Cores: Novo sistema de tokens",
-        "Plugins: API diferente",
-      ],
-      steps: [
-        "Atualizar tailwindcss para ^4.0.0",
-        "Converter tailwind.config.js para CSS",
-        "Atualizar globals.css com @import 'tailwindcss'",
-        "Revisar @apply usages",
-        "Atualizar plugins para v4",
-        "Testar todas as paginas",
-      ],
-    }
-  },
-
-  bun: () => ({
-    current: "pnpm/npm/yarn",
-    target: "bun",
-    complexity: "low",
-    breakingChanges: [
-      "Lockfile: Formato diferente (bun.lockb)",
-      "Scripts: Alguns podem precisar ajuste",
-      "Workspaces: Sintaxe levemente diferente",
-    ],
-    steps: [
-      "Remover node_modules",
-      "Remover pnpm-lock.yaml / package-lock.json / yarn.lock",
-      "Executar: bun install",
-      "Atualizar scripts no package.json (npx -> bunx)",
-      "Atualizar CI/CD configs",
-      "Testar: bun dev, bun build",
-    ],
-  }),
-
-  drizzle: () => ({
-    current: "prisma",
-    target: "drizzle",
-    complexity: "high",
-    breakingChanges: [
-      "Schema: Formato TypeScript (nao mais .prisma)",
-      "Queries: API completamente diferente",
-      "Migrations: Sistema diferente",
-      "Relations: Declaracao diferente",
-    ],
-    steps: [
-      "Instalar drizzle-orm e drizzle-kit",
-      "Converter schema.prisma para drizzle/schema.ts",
-      "Configurar drizzle.config.ts",
-      "Gerar migrations: bunx drizzle-kit generate",
-      "Atualizar todas as queries",
-      "Atualizar auth config (se usar)",
-      "Remover @prisma/client e prisma",
-      "Testar todas as operacoes de banco",
-    ],
-  }),
-}
-
-export async function upgrade(args: string[]) {
-  const showPlan = args.includes("--plan")
-  const target = args.find(a => !a.startsWith("-"))
-
-  console.log()
-
-  if (showPlan || !target) {
-    // Analyze first
-    console.log(pc.cyan("  Analisando projeto para plano de upgrade..."))
-    console.log()
-
-    const analysis = await analyze([".", "--quiet"])
-
-    console.log(pc.bold("  Upgrades Disponiveis:"))
-    console.log()
-
-    let hasUpgrades = false
-
-    // Check Next.js
-    if (analysis.frameworkVersion && analysis.framework === "nextjs") {
-      const planFn = UPGRADE_PLANS["next"]
-      if (planFn) {
-        const plan = planFn(analysis.frameworkVersion)
-        if (plan) {
-          hasUpgrades = true
-          printUpgradePlan("Next.js", plan)
-        }
-      }
-    }
-
-    // Check React
-    if (analysis.dependencies["react"]) {
-      const planFn = UPGRADE_PLANS["react"]
-      if (planFn) {
-        const plan = planFn(analysis.dependencies["react"])
-        if (plan) {
-          hasUpgrades = true
-          printUpgradePlan("React", plan)
-        }
-      }
-    }
-
-    // Check Tailwind
-    const tailwindDep = analysis.dependencies["tailwindcss"] || analysis.devDependencies["tailwindcss"]
-    if (tailwindDep) {
-      const planFn = UPGRADE_PLANS["tailwind"]
-      if (planFn) {
-        const plan = planFn(tailwindDep)
-        if (plan) {
-          hasUpgrades = true
-          printUpgradePlan("Tailwind CSS", plan)
-        }
-      }
-    }
-
-    // Check package manager
-    if (analysis.packageManager !== "bun") {
-      const planFn = UPGRADE_PLANS["bun"]
-      if (planFn) {
-        const plan = planFn("")
-        if (plan) {
-          hasUpgrades = true
-          printUpgradePlan("Package Manager", plan)
-        }
-      }
-    }
-
-    // Check Prisma -> Drizzle
-    if (analysis.database === "prisma") {
-      const planFn = UPGRADE_PLANS["drizzle"]
-      if (planFn) {
-        const plan = planFn("")
-        if (plan) {
-          hasUpgrades = true
-          printUpgradePlan("Database", plan)
-        }
-      }
-    }
-
-    if (!hasUpgrades) {
-      console.log(pc.green("  Projeto ja esta atualizado!"))
-    }
-
-    console.log()
-    console.log(pc.dim("  Para executar um upgrade especifico:"))
-    console.log(pc.dim("    nimbus upgrade next"))
-    console.log(pc.dim("    nimbus upgrade tailwind"))
-    console.log(pc.dim("    nimbus upgrade bun"))
-    console.log()
-
-    return
-  }
-
-  // Execute specific upgrade
-  console.log(pc.yellow(`  Upgrade ${target} ainda nao implementado.`))
-  console.log(pc.dim("  Por enquanto, siga os passos do --plan manualmente."))
-  console.log()
-}
-
-function printUpgradePlan(name: string, plan: UpgradePlan) {
-  const complexityColor = {
-    low: pc.green,
-    medium: pc.yellow,
-    high: pc.red,
-  }
-
-  console.log(`  ${pc.bold(name)}`)
-  console.log(`    ${pc.dim("Atual:")} ${plan.current} ${pc.dim("->")} ${pc.cyan(plan.target)}`)
-  console.log(`    ${pc.dim("Complexidade:")} ${complexityColor[plan.complexity](plan.complexity)}`)
-  console.log()
-
-  console.log(`    ${pc.dim("Breaking Changes:")}`)
-  plan.breakingChanges.forEach(bc => {
-    console.log(`      ${pc.yellow("!")} ${bc}`)
-  })
-  console.log()
-
-  console.log(`    ${pc.dim("Passos:")}`)
-  plan.steps.forEach((step, i) => {
-    console.log(`      ${pc.dim(`${i + 1}.`)} ${step}`)
-  })
-  console.log()
-}