@nimbuslab/cli 0.14.0 → 0.16.0

package/src/commands/update.ts

@@ -4,6 +4,8 @@ import { execSync, spawnSync } from "child_process"
 
 const PACKAGE_NAME = "@nimbuslab/cli"
 
+type PackageManager = "bun" | "npm" | "unknown"
+
 async function getAvailableVersions(): Promise<string[]> {
   try {
     const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}`)
@@ -26,91 +28,166 @@ async function getLatestVersion(): Promise<string | null> {
   }
 }
 
+// Detecta qual package manager tem o pacote instalado globalmente
+function detectPackageManager(): PackageManager {
+  // Tentar bun primeiro
+  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
+  }
+
+  // Tentar npm
+  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
+  }
+
+  return "unknown"
+}
+
 function getCurrentVersion(): string {
+  // Tentar bun primeiro
+  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
+  }
+
+  // Fallback para npm
   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]?.version || "unknown"
+      if (data.dependencies?.[PACKAGE_NAME]?.version) {
+        return data.dependencies[PACKAGE_NAME].version
+      }
     }
   } catch {
     // ignore
   }
+
   return "unknown"
 }
 
 export async function update(args: string[]) {
-  const flag = args[0]
+  // 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("Versões disponíveis"))
+    p.intro(pc.cyan("Versoes disponiveis"))
 
     const spinner = p.spinner()
-    spinner.start("Buscando versões...")
+    spinner.start("Buscando versoes...")
 
     const versions = await getAvailableVersions()
-    spinner.stop("Versões encontradas")
+    spinner.stop("Versoes encontradas")
 
     if (versions.length === 0) {
-      p.log.error("Não foi possível buscar as versões")
+      p.log.error("Nao foi possivel buscar as versoes")
       return
     }
 
     const current = getCurrentVersion()
+    const pm = detectPackageManager()
 
     console.log()
-    console.log(pc.bold("Últimas 10 versões:"))
+    console.log(pc.bold("Ultimas 10 versoes:"))
     versions.slice(0, 10).forEach((v, i) => {
       const isCurrent = v === current
-      const prefix = isCurrent ? pc.green("→ ") : "  "
+      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} versões`))
-    console.log(pc.dim(`Instalar versão específica: nimbus update <versão>`))
+    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"
+  const isSpecificVersion = flag && flag !== "latest" && !flag.startsWith("-")
 
   p.intro(pc.cyan(`Atualizando ${PACKAGE_NAME}`))
 
   const spinner = p.spinner()
 
-  // Verificar versão atual
-  spinner.start("Verificando versão atual...")
+  // Detectar package manager
+  spinner.start("Detectando package manager...")
+  const detectedPm = detectPackageManager()
+  // Usar bun como padrao se nenhum detectado
+  const pm = detectedPm === "unknown" ? "bun" : detectedPm
+  spinner.stop(`Package manager: ${pm}${detectedPm === "unknown" ? " (padrao)" : ""}`)
+
+  // Verificar versao atual
+  spinner.start("Verificando versao atual...")
   const currentVersion = getCurrentVersion()
-  spinner.stop(`Versão atual: ${currentVersion}`)
+  spinner.stop(`Versao atual: ${currentVersion === "unknown" ? "nao instalado" : currentVersion}`)
 
-  // Verificar versão alvo
+  // Verificar versao alvo
+  let latestVersion: string | null = null
   if (!isSpecificVersion) {
-    spinner.start("Verificando última versão...")
-    const latest = await getLatestVersion()
-    spinner.stop(`Última versão: ${latest || "desconhecida"}`)
+    spinner.start("Verificando ultima versao no npm...")
+    latestVersion = await getLatestVersion()
+    spinner.stop(`Ultima versao: ${latestVersion || "desconhecida"}`)
 
-    if (latest && latest === currentVersion) {
-      p.log.success("Você já está na última versão!")
+    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 : "latest"
+  const versionText = isSpecificVersion ? targetVersion : (latestVersion || "latest")
+  const actionText = forceFlag ? "Reinstalar" : "Atualizar"
   const confirmUpdate = await p.confirm({
-    message: `Atualizar para ${versionText}?`,
+    message: `${actionText} para ${versionText} usando ${pm}?`,
     initialValue: true,
   })
 
   if (p.isCancel(confirmUpdate) || !confirmUpdate) {
-    p.cancel("Atualização cancelada")
+    p.cancel("Atualizacao cancelada")
     return
   }
 
@@ -120,23 +197,40 @@ export async function update(args: string[]) {
   try {
     const packageSpec = isSpecificVersion
       ? `${PACKAGE_NAME}@${targetVersion}`
-      : PACKAGE_NAME
-
-    // Usar npm para instalação global (mais estável que bun)
-    execSync(`npm install -g ${packageSpec}`, {
-      stdio: "pipe",
-      encoding: "utf-8",
-    })
+      : 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("Atualização concluída!")
+    spinner.stop("Atualizacao concluida!")
 
-    // Verificar nova versão
+    // Verificar nova versao
     const newVersion = getCurrentVersion()
 
-    p.log.success(`${PACKAGE_NAME} atualizado: ${currentVersion} → ${newVersion}`)
+    if (currentVersion === newVersion && !forceFlag) {
+      p.log.warn("Versao nao mudou. Tente com --force")
+    } else {
+      p.log.success(`${PACKAGE_NAME} atualizado: ${currentVersion} -> ${newVersion}`)
+    }
     p.outro(pc.green("Pronto!"))
   } catch (error) {
-    spinner.stop("Erro na atualização")
+    spinner.stop("Erro na atualizacao")
 
     const err = error as Error & { stderr?: string }
     p.log.error("Falha ao atualizar")
@@ -147,6 +241,10 @@ export async function update(args: string[]) {
 
     console.log()
     console.log(pc.yellow("Tente manualmente:"))
-    console.log(pc.cyan(`  npm install -g ${PACKAGE_NAME}${isSpecificVersion ? `@${targetVersion}` : ""}`))
+    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/index.ts

@@ -126,9 +126,10 @@ ${pc.bold("Analyze & Upgrade:")}
   upgrade tailwind Atualizar Tailwind CSS
 
 ${pc.bold("Update (CLI):")}
-  update           Atualizar para última versão
-  update 0.11.0    Instalar versão específica
-  update --list    Listar versões disponíveis
+  update           Atualizar para ultima versao
+  update 0.11.0    Instalar versao especifica
+  update --list    Listar versoes disponiveis
+  update --force   Forcar reinstalacao (limpa cache)
 
 ${pc.bold("Opções:")}
   -y, --yes        Aceitar padrões