@nimbuslab/cli 0.7.0 → 0.9.0

package/docs/CI-CD.md

@@ -161,12 +161,21 @@ O npm suporta autenticacao via OIDC, eliminando necessidade de tokens.
 
 ### 2026-01-26: Publicacao falhando silenciosamente
 
-**Problema**: CI mostrava sucesso mas versao nao aparecia no npm.
+**Problema**: CI mostrava sucesso (`+ @nimbuslab/cli@0.6.x`) mas versao nao aparecia no npm. Tarball retornava 404 com mensagem "Access token expired or revoked".
 
-**Causa**: OIDC Trusted Publishing falhando silenciosamente (config no npmjs.com ou bug do npm).
+**Causa**: OIDC Trusted Publishing falhando silenciosamente. Os tarballs eram criados mas ficavam inacessiveis.
 
 **Solucao**: Adicionar `NODE_AUTH_TOKEN` como fallback junto com OIDC.
 
+```yaml
+- name: Publish to npm
+  run: npm publish --access public
+  env:
+    NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+```
+
+**Importante**: Mesmo com OIDC configurado, SEMPRE manter o `NODE_AUTH_TOKEN` como fallback. O token deve ser do tipo "Granular Access Token" (nao "Classic", que foi deprecado em dez/2025).
+
 ---
 
 *Ultima atualizacao: 2026-01-26*

package/package.json

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

package/src/commands/analyze.ts

@@ -0,0 +1,210 @@
+import * as p from "@clack/prompts"
+import pc from "picocolors"
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+interface AnalysisResult {
+  name: string
+  version: string
+  framework: string | null
+  frameworkVersion: string | null
+  styling: string[]
+  packageManager: string
+  monorepo: string | null
+  auth: string | null
+  database: string | null
+  typescript: boolean
+  dependencies: Record<string, string>
+  devDependencies: Record<string, string>
+  recommendations: string[]
+}
+
+function detectPackageManager(dir: string): string {
+  if (existsSync(join(dir, "bun.lockb"))) return "bun"
+  if (existsSync(join(dir, "pnpm-lock.yaml"))) return "pnpm"
+  if (existsSync(join(dir, "yarn.lock"))) return "yarn"
+  if (existsSync(join(dir, "package-lock.json"))) return "npm"
+  return "unknown"
+}
+
+function detectMonorepo(dir: string, pkg: any): string | null {
+  if (existsSync(join(dir, "turbo.json"))) return "turborepo"
+  if (existsSync(join(dir, "nx.json"))) return "nx"
+  if (existsSync(join(dir, "lerna.json"))) return "lerna"
+  if (pkg.workspaces) return "workspaces"
+  return null
+}
+
+function detectFramework(deps: Record<string, string>): { name: string | null; version: string | null } {
+  if (deps["next"]) return { name: "nextjs", version: deps["next"] }
+  if (deps["@angular/core"]) return { name: "angular", version: deps["@angular/core"] }
+  if (deps["vue"]) return { name: "vue", version: deps["vue"] }
+  if (deps["svelte"]) return { name: "svelte", version: deps["svelte"] }
+  if (deps["react"] && !deps["next"]) return { name: "react", version: deps["react"] }
+  return { name: null, version: null }
+}
+
+function detectStyling(deps: Record<string, string>, devDeps: Record<string, string>): string[] {
+  const styling: string[] = []
+  const allDeps = { ...deps, ...devDeps }
+
+  if (allDeps["tailwindcss"]) styling.push(`tailwind@${allDeps["tailwindcss"]}`)
+  if (allDeps["styled-components"]) styling.push("styled-components")
+  if (allDeps["@emotion/react"]) styling.push("emotion")
+  if (allDeps["sass"]) styling.push("sass")
+  if (allDeps["less"]) styling.push("less")
+
+  return styling.length > 0 ? styling : ["css"]
+}
+
+function detectAuth(deps: Record<string, string>): string | null {
+  if (deps["better-auth"]) return "better-auth"
+  if (deps["next-auth"]) return "next-auth"
+  if (deps["@clerk/nextjs"]) return "clerk"
+  if (deps["@auth0/nextjs-auth0"]) return "auth0"
+  if (deps["@supabase/supabase-js"]) return "supabase"
+  return null
+}
+
+function detectDatabase(deps: Record<string, string>): string | null {
+  if (deps["drizzle-orm"]) return "drizzle"
+  if (deps["@prisma/client"]) return "prisma"
+  if (deps["typeorm"]) return "typeorm"
+  if (deps["mongoose"]) return "mongoose"
+  if (deps["pg"]) return "pg"
+  if (deps["mysql2"]) return "mysql"
+  return null
+}
+
+function generateRecommendations(result: AnalysisResult): string[] {
+  const recs: string[] = []
+
+  // Package manager
+  if (result.packageManager !== "bun") {
+    recs.push(`Migrar ${result.packageManager} -> bun (nimbus codemod bun)`)
+  }
+
+  // Framework version
+  if (result.framework === "nextjs" && result.frameworkVersion) {
+    const majorVersion = parseInt(result.frameworkVersion.replace(/[^0-9]/g, "").slice(0, 2))
+    if (majorVersion < 16) {
+      recs.push(`Atualizar Next.js ${result.frameworkVersion} -> 16 (nimbus upgrade next)`)
+    }
+  }
+
+  // Tailwind
+  const tailwind = result.styling.find(s => s.startsWith("tailwind"))
+  if (tailwind) {
+    const version = tailwind.split("@")[1] || ""
+    if (version.startsWith("3")) {
+      recs.push(`Atualizar Tailwind 3 -> 4 (nimbus upgrade tailwind)`)
+    }
+  } else if (!result.styling.includes("tailwind")) {
+    recs.push(`Considerar adicionar Tailwind CSS (nimbus add tailwind)`)
+  }
+
+  // React version
+  if (result.dependencies["react"]) {
+    const reactVersion = result.dependencies["react"]
+    if (reactVersion.startsWith("18") || reactVersion.startsWith("^18")) {
+      recs.push(`Atualizar React 18 -> 19 (nimbus upgrade react)`)
+    }
+  }
+
+  // Database
+  if (result.database === "prisma") {
+    recs.push(`Considerar migrar Prisma -> Drizzle (nimbus codemod drizzle)`)
+  } else if (!result.database && result.framework === "nextjs") {
+    recs.push(`Considerar adicionar banco de dados (nimbus add db)`)
+  }
+
+  // Auth
+  if (!result.auth && result.framework === "nextjs") {
+    recs.push(`Considerar adicionar autenticacao (nimbus add auth)`)
+  } else if (result.auth === "next-auth") {
+    recs.push(`Considerar migrar NextAuth -> Better Auth`)
+  }
+
+  // Monorepo
+  if (result.monorepo === "workspaces" && !result.monorepo) {
+    recs.push(`Considerar usar Turborepo para monorepo (nimbus add monorepo)`)
+  }
+
+  return recs
+}
+
+export async function analyze(args: string[]) {
+  const targetDir = args[0] || "."
+  const absoluteDir = targetDir.startsWith("/") ? targetDir : join(process.cwd(), targetDir)
+
+  console.log()
+  console.log(pc.cyan("  Analisando projeto..."))
+  console.log()
+
+  // Check if package.json exists
+  const pkgPath = join(absoluteDir, "package.json")
+  if (!existsSync(pkgPath)) {
+    console.log(pc.red("  Erro: package.json nao encontrado"))
+    console.log(pc.dim(`  Diretorio: ${absoluteDir}`))
+    process.exit(1)
+  }
+
+  // Read package.json
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
+  const deps = pkg.dependencies || {}
+  const devDeps = pkg.devDependencies || {}
+
+  // Detect everything
+  const framework = detectFramework(deps)
+  const result: AnalysisResult = {
+    name: pkg.name || "unknown",
+    version: pkg.version || "0.0.0",
+    framework: framework.name,
+    frameworkVersion: framework.version,
+    styling: detectStyling(deps, devDeps),
+    packageManager: detectPackageManager(absoluteDir),
+    monorepo: detectMonorepo(absoluteDir, pkg),
+    auth: detectAuth(deps),
+    database: detectDatabase(deps),
+    typescript: existsSync(join(absoluteDir, "tsconfig.json")),
+    dependencies: deps,
+    devDependencies: devDeps,
+    recommendations: [],
+  }
+
+  // Generate recommendations
+  result.recommendations = generateRecommendations(result)
+
+  // Display results
+  console.log(pc.bold("  Projeto: ") + pc.cyan(result.name) + pc.dim(` v${result.version}`))
+  console.log()
+
+  console.log(pc.bold("  Stack Detectada:"))
+  console.log(`    Framework:       ${result.framework ? pc.green(result.framework + "@" + result.frameworkVersion) : pc.dim("nenhum")}`)
+  console.log(`    Styling:         ${result.styling.map(s => pc.green(s)).join(", ")}`)
+  console.log(`    Package Manager: ${result.packageManager === "bun" ? pc.green(result.packageManager) : pc.yellow(result.packageManager)}`)
+  console.log(`    TypeScript:      ${result.typescript ? pc.green("sim") : pc.dim("nao")}`)
+  console.log(`    Monorepo:        ${result.monorepo ? pc.green(result.monorepo) : pc.dim("nao")}`)
+  console.log(`    Auth:            ${result.auth ? pc.green(result.auth) : pc.dim("nenhum")}`)
+  console.log(`    Database:        ${result.database ? pc.green(result.database) : pc.dim("nenhum")}`)
+  console.log()
+
+  if (result.recommendations.length > 0) {
+    console.log(pc.bold("  Recomendacoes:"))
+    result.recommendations.forEach((rec, i) => {
+      console.log(pc.yellow(`    ${i + 1}. ${rec}`))
+    })
+    console.log()
+  } else {
+    console.log(pc.green("  Projeto ja esta na stack recomendada!"))
+    console.log()
+  }
+
+  // JSON output option
+  if (args.includes("--json")) {
+    console.log(pc.dim("  JSON:"))
+    console.log(JSON.stringify(result, null, 2))
+  }
+
+  return result
+}