@nimbuslab/cli 0.14.0 → 0.15.0

package/.github/workflows/publish.yml

@@ -16,27 +16,52 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
+      - name: Check if version changed
+        id: version_check
+        run: |
+          LOCAL_VERSION=$(node -p "require('./package.json').version")
+          NPM_VERSION=$(npm view @nimbuslab/cli version 2>/dev/null || echo "0.0.0")
+          echo "local=$LOCAL_VERSION" >> $GITHUB_OUTPUT
+          echo "npm=$NPM_VERSION" >> $GITHUB_OUTPUT
+          if [ "$LOCAL_VERSION" = "$NPM_VERSION" ]; then
+            echo "changed=false" >> $GITHUB_OUTPUT
+            echo "Versao $LOCAL_VERSION ja existe no npm. Pulando publish."
+          else
+            echo "changed=true" >> $GITHUB_OUTPUT
+            echo "Nova versao detectada: $NPM_VERSION -> $LOCAL_VERSION"
+          fi
+
       - name: Setup Bun
+        if: steps.version_check.outputs.changed == 'true'
         uses: oven-sh/setup-bun@v2
         with:
           bun-version: latest
 
       - name: Setup Node (for npm publish)
+        if: steps.version_check.outputs.changed == 'true'
         uses: actions/setup-node@v4
         with:
           node-version: "24"
           registry-url: "https://registry.npmjs.org"
 
       - name: Install dependencies
+        if: steps.version_check.outputs.changed == 'true'
         run: bun install
 
       - name: Typecheck
+        if: steps.version_check.outputs.changed == 'true'
         run: bun run typecheck
 
       - name: Build
+        if: steps.version_check.outputs.changed == 'true'
         run: bun run build
 
       - name: Publish to npm
+        if: steps.version_check.outputs.changed == 'true'
         run: npm publish --access public
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Skip message
+        if: steps.version_check.outputs.changed == 'false'
+        run: echo "Publish pulado - versao ${{ steps.version_check.outputs.local }} ja existe no npm"

package/dist/index.js

@@ -150,7 +150,7 @@ var require_src = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@nimbuslab/cli",
-    version: "0.14.0",
+    version: "0.15.0",
     description: "CLI para criar projetos nimbuslab",
     type: "module",
     bin: {
@@ -2382,84 +2382,149 @@ async function getLatestVersion() {
     return null;
   }
 }
+function detectPackageManager2() {
+  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 {}
+  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 {}
+  return "unknown";
+}
 function getCurrentVersion() {
+  try {
+    const bunResult = spawnSync("bun", ["pm", "ls", "-g"], {
+      encoding: "utf-8",
+      shell: true,
+      timeout: 5000
+    });
+    if (bunResult.stdout) {
+      const match = bunResult.stdout.match(new RegExp(`${PACKAGE_NAME.replace("/", "\\/")}@([\\d.]+)`));
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+  } catch {}
   try {
     const result = spawnSync("npm", ["ls", "-g", PACKAGE_NAME, "--json"], {
       encoding: "utf-8",
-      shell: true
+      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 {}
   return "unknown";
 }
 async function update(args) {
-  const flag = args[0];
+  const forceFlag = args.includes("--force") || args.includes("-f");
+  const filteredArgs = args.filter((a) => a !== "--force" && a !== "-f");
+  const flag = filteredArgs[0];
   if (flag === "--list" || flag === "-l") {
-    Ie(import_picocolors6.default.cyan("Vers\xF5es dispon\xEDveis"));
+    Ie(import_picocolors6.default.cyan("Versoes disponiveis"));
     const spinner2 = Y2();
-    spinner2.start("Buscando vers\xF5es...");
+    spinner2.start("Buscando versoes...");
     const versions = await getAvailableVersions();
-    spinner2.stop("Vers\xF5es encontradas");
+    spinner2.stop("Versoes encontradas");
     if (versions.length === 0) {
-      M2.error("N\xE3o foi poss\xEDvel buscar as vers\xF5es");
+      M2.error("Nao foi possivel buscar as versoes");
       return;
     }
     const current = getCurrentVersion();
+    const pm2 = detectPackageManager2();
     console.log();
-    console.log(import_picocolors6.default.bold("\xDAltimas 10 vers\xF5es:"));
+    console.log(import_picocolors6.default.bold("Ultimas 10 versoes:"));
     versions.slice(0, 10).forEach((v2, i) => {
       const isCurrent = v2 === current;
-      const prefix = isCurrent ? import_picocolors6.default.green("\u2192 ") : "  ";
+      const prefix = isCurrent ? import_picocolors6.default.green("-> ") : "   ";
       const suffix = isCurrent ? import_picocolors6.default.dim(" (instalada)") : "";
       const isLatest = i === 0 ? import_picocolors6.default.yellow(" (latest)") : "";
       console.log(`${prefix}${v2}${suffix}${isLatest}`);
     });
     console.log();
-    console.log(import_picocolors6.default.dim(`Total: ${versions.length} vers\xF5es`));
-    console.log(import_picocolors6.default.dim(`Instalar vers\xE3o espec\xEDfica: nimbus update <vers\xE3o>`));
+    console.log(import_picocolors6.default.dim(`Total: ${versions.length} versoes`));
+    console.log(import_picocolors6.default.dim(`Package manager detectado: ${pm2 === "unknown" ? "nenhum" : pm2}`));
+    console.log(import_picocolors6.default.dim(`Instalar versao especifica: nimbus update <versao>`));
+    console.log(import_picocolors6.default.dim(`Forcar reinstalacao: nimbus update --force`));
     return;
   }
   const targetVersion = flag || "latest";
-  const isSpecificVersion = flag && flag !== "latest";
+  const isSpecificVersion = flag && flag !== "latest" && !flag.startsWith("-");
   Ie(import_picocolors6.default.cyan(`Atualizando ${PACKAGE_NAME}`));
   const spinner = Y2();
-  spinner.start("Verificando vers\xE3o atual...");
+  spinner.start("Detectando package manager...");
+  const detectedPm = detectPackageManager2();
+  const pm = detectedPm === "unknown" ? "bun" : detectedPm;
+  spinner.stop(`Package manager: ${pm}${detectedPm === "unknown" ? " (padrao)" : ""}`);
+  spinner.start("Verificando versao atual...");
   const currentVersion = getCurrentVersion();
-  spinner.stop(`Vers\xE3o atual: ${currentVersion}`);
+  spinner.stop(`Versao atual: ${currentVersion === "unknown" ? "nao instalado" : currentVersion}`);
+  let latestVersion = null;
   if (!isSpecificVersion) {
-    spinner.start("Verificando \xFAltima vers\xE3o...");
-    const latest = await getLatestVersion();
-    spinner.stop(`\xDAltima vers\xE3o: ${latest || "desconhecida"}`);
-    if (latest && latest === currentVersion) {
-      M2.success("Voc\xEA j\xE1 est\xE1 na \xFAltima vers\xE3o!");
+    spinner.start("Verificando ultima versao no npm...");
+    latestVersion = await getLatestVersion();
+    spinner.stop(`Ultima versao: ${latestVersion || "desconhecida"}`);
+    if (!forceFlag && latestVersion && latestVersion === currentVersion) {
+      M2.success("Voce ja esta na ultima versao!");
+      console.log(import_picocolors6.default.dim("  Use --force para reinstalar"));
       return;
     }
   }
-  const versionText = isSpecificVersion ? targetVersion : "latest";
+  const versionText = isSpecificVersion ? targetVersion : latestVersion || "latest";
+  const actionText = forceFlag ? "Reinstalar" : "Atualizar";
   const confirmUpdate = await ye({
-    message: `Atualizar para ${versionText}?`,
+    message: `${actionText} para ${versionText} usando ${pm}?`,
     initialValue: true
   });
   if (pD(confirmUpdate) || !confirmUpdate) {
-    xe("Atualiza\xE7\xE3o cancelada");
+    xe("Atualizacao cancelada");
     return;
   }
   spinner.start("Atualizando...");
   try {
-    const packageSpec = isSpecificVersion ? `${PACKAGE_NAME}@${targetVersion}` : PACKAGE_NAME;
-    execSync(`npm install -g ${packageSpec}`, {
-      stdio: "pipe",
-      encoding: "utf-8"
-    });
-    spinner.stop("Atualiza\xE7\xE3o conclu\xEDda!");
+    const packageSpec = isSpecificVersion ? `${PACKAGE_NAME}@${targetVersion}` : latestVersion ? `${PACKAGE_NAME}@${latestVersion}` : PACKAGE_NAME;
+    if (pm === "bun") {
+      if (forceFlag) {
+        try {
+          execSync(`bun remove -g ${PACKAGE_NAME}`, { stdio: "pipe", encoding: "utf-8" });
+        } catch {}
+      }
+      execSync(`bun add -g ${packageSpec}`, { stdio: "pipe", encoding: "utf-8" });
+    } else {
+      const forceArg = forceFlag ? " --force" : "";
+      execSync(`npm install -g ${packageSpec}${forceArg}`, { stdio: "pipe", encoding: "utf-8" });
+    }
+    spinner.stop("Atualizacao concluida!");
     const newVersion = getCurrentVersion();
-    M2.success(`${PACKAGE_NAME} atualizado: ${currentVersion} \u2192 ${newVersion}`);
+    if (currentVersion === newVersion && !forceFlag) {
+      M2.warn("Versao nao mudou. Tente com --force");
+    } else {
+      M2.success(`${PACKAGE_NAME} atualizado: ${currentVersion} -> ${newVersion}`);
+    }
     Se(import_picocolors6.default.green("Pronto!"));
   } catch (error) {
-    spinner.stop("Erro na atualiza\xE7\xE3o");
+    spinner.stop("Erro na atualizacao");
     const err = error;
     M2.error("Falha ao atualizar");
     if (err.stderr) {
@@ -2467,7 +2532,11 @@ async function update(args) {
     }
     console.log();
     console.log(import_picocolors6.default.yellow("Tente manualmente:"));
-    console.log(import_picocolors6.default.cyan(`  npm install -g ${PACKAGE_NAME}${isSpecificVersion ? `@${targetVersion}` : ""}`));
+    if (pm === "bun") {
+      console.log(import_picocolors6.default.cyan(`  bun add -g ${PACKAGE_NAME}${isSpecificVersion ? `@${targetVersion}` : ""}`));
+    } else {
+      console.log(import_picocolors6.default.cyan(`  npm install -g ${PACKAGE_NAME}${isSpecificVersion ? `@${targetVersion}` : ""}`));
+    }
   }
 }
 
@@ -2536,11 +2605,36 @@ async function installLola() {
   if (isUpdate) {
     console.log(import_picocolors7.default.dim(`  Lola ja instalada em ${LOLA_DIR}`));
     console.log(import_picocolors7.default.cyan("  Atualizando..."));
+    const statusCheck = Bun.spawnSync(["git", "status", "--porcelain"], {
+      cwd: LOLA_DIR,
+      stdout: "pipe"
+    });
+    const hasLocalChanges = statusCheck.stdout.toString().trim().length > 0;
+    if (hasLocalChanges) {
+      console.log(import_picocolors7.default.dim("  Salvando mudancas locais..."));
+      Bun.spawnSync(["git", "stash", "--quiet"], {
+        cwd: LOLA_DIR,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+    }
     const result = Bun.spawnSync(["git", "pull", "--quiet"], {
       cwd: LOLA_DIR,
       stdout: "inherit",
       stderr: "inherit"
     });
+    if (hasLocalChanges) {
+      console.log(import_picocolors7.default.dim("  Restaurando mudancas locais..."));
+      const stashPop = Bun.spawnSync(["git", "stash", "pop", "--quiet"], {
+        cwd: LOLA_DIR,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      if (stashPop.exitCode !== 0) {
+        console.log(import_picocolors7.default.yellow("  Aviso: conflito ao restaurar mudancas locais"));
+        console.log(import_picocolors7.default.dim("  Verifique ~/.lola e resolva manualmente: git stash pop"));
+      }
+    }
     if (result.exitCode !== 0) {
       console.log(import_picocolors7.default.red("  Erro ao atualizar Lola"));
       process.exit(1);
@@ -3176,9 +3270,10 @@ ${import_picocolors8.default.bold("Analyze & Upgrade:")}
   upgrade tailwind Atualizar Tailwind CSS
 
 ${import_picocolors8.default.bold("Update (CLI):")}
-  update           Atualizar para \xFAltima vers\xE3o
-  update 0.11.0    Instalar vers\xE3o espec\xEDfica
-  update --list    Listar vers\xF5es dispon\xEDveis
+  update           Atualizar para ultima versao
+  update 0.11.0    Instalar versao especifica
+  update --list    Listar versoes disponiveis
+  update --force   Forcar reinstalacao (limpa cache)
 
 ${import_picocolors8.default.bold("Op\xE7\xF5es:")}
   -y, --yes        Aceitar padr\xF5es

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbuslab/cli",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "CLI para criar projetos nimbuslab",
   "type": "module",
   "bin": {

package/src/commands/lola.ts

@@ -73,12 +73,45 @@ async function installLola(): Promise<void> {
     console.log(pc.dim(`  Lola ja instalada em ${LOLA_DIR}`))
     console.log(pc.cyan("  Atualizando..."))
 
+    // Verificar se tem mudancas locais
+    const statusCheck = Bun.spawnSync(["git", "status", "--porcelain"], {
+      cwd: LOLA_DIR,
+      stdout: "pipe",
+    })
+    const hasLocalChanges = statusCheck.stdout.toString().trim().length > 0
+
+    // Stash se tiver mudancas locais
+    if (hasLocalChanges) {
+      console.log(pc.dim("  Salvando mudancas locais..."))
+      Bun.spawnSync(["git", "stash", "--quiet"], {
+        cwd: LOLA_DIR,
+        stdout: "pipe",
+        stderr: "pipe",
+      })
+    }
+
+    // Pull
     const result = Bun.spawnSync(["git", "pull", "--quiet"], {
       cwd: LOLA_DIR,
       stdout: "inherit",
       stderr: "inherit",
     })
 
+    // Restaurar mudancas locais se tinha
+    if (hasLocalChanges) {
+      console.log(pc.dim("  Restaurando mudancas locais..."))
+      const stashPop = Bun.spawnSync(["git", "stash", "pop", "--quiet"], {
+        cwd: LOLA_DIR,
+        stdout: "pipe",
+        stderr: "pipe",
+      })
+
+      if (stashPop.exitCode !== 0) {
+        console.log(pc.yellow("  Aviso: conflito ao restaurar mudancas locais"))
+        console.log(pc.dim("  Verifique ~/.lola e resolva manualmente: git stash pop"))
+      }
+    }
+
     if (result.exitCode !== 0) {
       console.log(pc.red("  Erro ao atualizar Lola"))
       process.exit(1)

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