novaui-cli 1.0.9 → 1.1.2

package/src/themes/sunset.js

@@ -0,0 +1,51 @@
+export const SUNSET_THEME_CSS = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    --background: 24 100% 98%;
+    --foreground: 12 30% 18%;
+    --card: 0 0% 100%;
+    --card-foreground: 12 30% 18%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 12 30% 18%;
+    --primary: 18 95% 53%;
+    --primary-foreground: 0 0% 100%;
+    --secondary: 22 78% 92%;
+    --secondary-foreground: 16 32% 26%;
+    --muted: 22 78% 92%;
+    --muted-foreground: 18 20% 46%;
+    --accent: 340 84% 93%;
+    --accent-foreground: 336 32% 28%;
+    --destructive: 0 73% 54%;
+    --destructive-foreground: 0 0% 100%;
+    --border: 20 58% 84%;
+    --input: 20 58% 84%;
+    --ring: 18 95% 53%;
+    --radius: 0.75rem;
+  }
+
+  .dark {
+    --background: 16 46% 12%;
+    --foreground: 24 60% 95%;
+    --card: 15 42% 16%;
+    --card-foreground: 24 60% 95%;
+    --popover: 15 42% 16%;
+    --popover-foreground: 24 60% 95%;
+    --primary: 24 100% 64%;
+    --primary-foreground: 16 46% 12%;
+    --secondary: 11 28% 24%;
+    --secondary-foreground: 24 60% 95%;
+    --muted: 11 28% 24%;
+    --muted-foreground: 20 24% 72%;
+    --accent: 332 42% 30%;
+    --accent-foreground: 24 60% 95%;
+    --destructive: 0 62% 45%;
+    --destructive-foreground: 0 0% 100%;
+    --border: 14 24% 28%;
+    --input: 14 24% 28%;
+    --ring: 24 100% 64%;
+  }
+}
+`

package/src/utils/config.js

@@ -0,0 +1,22 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { CONFIG_FILENAME, DEFAULT_CONFIG } from '../constants.js'
+
+/** Load components.json from cwd; returns null if missing or invalid. */
+export function loadConfig(cwd) {
+  const configPath = path.join(cwd, CONFIG_FILENAME)
+  if (!fs.existsSync(configPath)) return null
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'))
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
+    return { ...DEFAULT_CONFIG, ...raw }
+  } catch {
+    return null
+  }
+}
+
+/** Write components.json to cwd. */
+export function writeConfig(cwd, config) {
+  const configPath = path.join(cwd, CONFIG_FILENAME)
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8')
+}

package/src/utils/deps.js

@@ -0,0 +1,36 @@
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+export function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || ''
+  if (userAgent.startsWith('yarn')) return { command: 'yarn', baseArgs: ['add'] }
+  if (userAgent.startsWith('pnpm')) return { command: 'pnpm', baseArgs: ['add'] }
+  if (userAgent.startsWith('bun')) return { command: 'bun', baseArgs: ['add'] }
+  return { command: 'npm', baseArgs: ['install'] }
+}
+
+export function installPackages(packages) {
+  if (!Array.isArray(packages) || packages.length === 0) return
+  const { command, baseArgs } = detectPackageManager()
+  execFileSync(command, [...baseArgs, ...packages], { stdio: 'inherit' })
+}
+
+export function getInstallHint(packages) {
+  const { command, baseArgs } = detectPackageManager()
+  return `${command} ${[...baseArgs, ...packages].join(' ')}`
+}
+
+/** Returns which of the requested deps are not listed in package.json (dependencies or devDependencies). */
+export function getMissingDeps(cwd, deps) {
+  const pkgPath = path.join(cwd, 'package.json')
+  if (!fs.existsSync(pkgPath)) {
+    return [...deps]
+  }
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+  const installed = new Set([
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.devDependencies || {}),
+  ])
+  return deps.filter(d => !installed.has(d))
+}

package/src/utils/fetch.js

@@ -0,0 +1,21 @@
+import { FETCH_TIMEOUT_MS } from '../constants.js'
+
+export async function fetchWithTimeout(url) {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS)
+  try {
+    return await fetch(url, { signal: controller.signal })
+  } catch (error) {
+    if (error && error.name === 'AbortError') {
+      throw new Error(`Request timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`)
+    }
+    throw error
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+export function formatError(error) {
+  if (error instanceof Error && error.message) return error.message
+  return String(error)
+}

package/src/utils/fs-helpers.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs'
+import pc from 'picocolors'
+
+export function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+}
+
+export function writeIfNotExists(filePath, content, label) {
+  if (fs.existsSync(filePath)) {
+    console.log(pc.dim(`   ℹ  ${label} already exists, skipping.`))
+    return false
+  }
+  fs.writeFileSync(filePath, content, 'utf8')
+  console.log(pc.green(`   ✓  Created ${label}`))
+  return true
+}

package/src/utils/tailwind.js

@@ -0,0 +1,60 @@
+export function getTailwindConfigContent(config) {
+  const normalized = config.componentsUi.replace(/^\.\//, '')
+  const contentPaths = ['"./App.{js,jsx,ts,tsx}"', '"./src/**/*.{js,jsx,ts,tsx}"']
+  if (!normalized.startsWith('src/')) {
+    contentPaths.push(`"./${normalized}/**/*.{js,jsx,ts,tsx}"`)
+  }
+  return `/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    ${contentPaths.join(',\n    ')},
+  ],
+  presets: [require("nativewind/preset")],
+  theme: {
+    extend: {
+      colors: {
+        border: "hsl(var(--border))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        primary: {
+          DEFAULT: "hsl(var(--primary))",
+          foreground: "hsl(var(--primary-foreground))",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary))",
+          foreground: "hsl(var(--secondary-foreground))",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive))",
+          foreground: "hsl(var(--destructive-foreground))",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted))",
+          foreground: "hsl(var(--muted-foreground))",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent))",
+          foreground: "hsl(var(--accent-foreground))",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover))",
+          foreground: "hsl(var(--popover-foreground))",
+        },
+        card: {
+          DEFAULT: "hsl(var(--card))",
+          foreground: "hsl(var(--card-foreground))",
+        },
+      },
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+    },
+  },
+  plugins: [],
+};
+`
+}

package/src/utils/validate.js

@@ -0,0 +1,17 @@
+export function assertValidComponentConfig(componentName, componentConfig) {
+  if (!componentConfig || typeof componentConfig !== 'object') {
+    throw new Error(`Registry entry for "${componentName}" is invalid.`)
+  }
+
+  const { files, dependencies } = componentConfig
+  if (!Array.isArray(files) || files.some(file => typeof file !== 'string' || file.trim() === '')) {
+    throw new Error(`Registry entry for "${componentName}" must include a valid "files" array.`)
+  }
+
+  if (
+    dependencies !== undefined &&
+    (!Array.isArray(dependencies) || dependencies.some(dep => typeof dep !== 'string' || dep.trim() === ''))
+  ) {
+    throw new Error(`Registry entry for "${componentName}" has an invalid "dependencies" array.`)
+  }
+}

package/src/utils/version.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const CLI_PACKAGE_JSON_PATH = path.resolve(__dirname, '../../package.json')
+
+export function getCliVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(CLI_PACKAGE_JSON_PATH, 'utf8'))
+    return pkg.version || 'unknown'
+  } catch {
+    return 'unknown'
+  }
+}

package/src/__tests__/commands.test.js

@@ -1,342 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest"
-import fs from "node:fs"
-import path from "node:path"
-import os from "node:os"
-
-import {
-  DEFAULT_CONFIG,
-  CONFIG_FILENAME,
-  GLOBAL_CSS_CONTENT,
-  UTILS_CONTENT,
-  getTailwindConfigContent,
-  loadConfig,
-  writeConfig,
-  init,
-  add,
-} from "../bin.js"
-
-// ─── Test helpers ───────────────────────────────────────────────────────────
-
-function makeTmpDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "novaui-cmd-test-"))
-}
-
-function cleanTmpDir(dir) {
-  fs.rmSync(dir, { recursive: true, force: true })
-}
-
-// ─── init command ───────────────────────────────────────────────────────────
-
-describe("init command", () => {
-  let tmp
-  let originalCwd
-
-  beforeEach(() => {
-    tmp = makeTmpDir()
-    originalCwd = process.cwd()
-    process.chdir(tmp)
-
-    // Create a minimal package.json so getMissingDeps works
-    fs.writeFileSync(
-      path.join(tmp, "package.json"),
-      JSON.stringify({
-        name: "test-project",
-        dependencies: {
-          nativewind: "^4.0.0",
-          tailwindcss: "^3.0.0",
-          clsx: "^2.0.0",
-          "tailwind-merge": "^3.0.0",
-          "class-variance-authority": "^0.7.0",
-        },
-      }),
-      "utf8"
-    )
-  })
-
-  afterEach(() => {
-    process.chdir(originalCwd)
-    cleanTmpDir(tmp)
-  })
-
-  it("creates components.json with default config", async () => {
-    // Non-TTY stdin means `ask()` returns defaults automatically
-    await init()
-
-    const configPath = path.join(tmp, CONFIG_FILENAME)
-    expect(fs.existsSync(configPath)).toBe(true)
-
-    const config = JSON.parse(fs.readFileSync(configPath, "utf8"))
-    expect(config.globalCss).toBe(DEFAULT_CONFIG.globalCss)
-    expect(config.componentsUi).toBe(DEFAULT_CONFIG.componentsUi)
-    expect(config.lib).toBe(DEFAULT_CONFIG.lib)
-  })
-
-  it("creates utils.ts in the lib directory", async () => {
-    await init()
-
-    const utilsPath = path.join(tmp, DEFAULT_CONFIG.lib, "utils.ts")
-    expect(fs.existsSync(utilsPath)).toBe(true)
-
-    const content = fs.readFileSync(utilsPath, "utf8")
-    expect(content).toContain("export function cn")
-    expect(content).toBe(UTILS_CONTENT)
-  })
-
-  it("creates global.css", async () => {
-    await init()
-
-    const cssPath = path.join(tmp, DEFAULT_CONFIG.globalCss)
-    expect(fs.existsSync(cssPath)).toBe(true)
-
-    const content = fs.readFileSync(cssPath, "utf8")
-    expect(content).toContain("@tailwind base")
-    expect(content).toContain("--primary:")
-    expect(content).toContain(".dark")
-    expect(content).toBe(GLOBAL_CSS_CONTENT)
-  })
-
-  it("creates tailwind.config.js with correct theme", async () => {
-    await init()
-
-    const twPath = path.join(tmp, "tailwind.config.js")
-    expect(fs.existsSync(twPath)).toBe(true)
-
-    const content = fs.readFileSync(twPath, "utf8")
-    expect(content).toContain("module.exports")
-    expect(content).toContain('require("nativewind/preset")')
-    expect(content).toContain("hsl(var(--primary))")
-    expect(content).toContain("hsl(var(--background))")
-    expect(content).toContain("hsl(var(--border))")
-    expect(content).toContain("var(--radius)")
-  })
-
-  it("does not overwrite existing files on second run", async () => {
-    await init()
-
-    // Modify utils.ts
-    const utilsPath = path.join(tmp, DEFAULT_CONFIG.lib, "utils.ts")
-    fs.writeFileSync(utilsPath, "// custom content")
-
-    await init()
-
-    // Should still have custom content
-    expect(fs.readFileSync(utilsPath, "utf8")).toBe("// custom content")
-  })
-
-  it("creates all expected directories", async () => {
-    await init()
-
-    expect(fs.existsSync(path.join(tmp, "src", "lib"))).toBe(true)
-    expect(fs.existsSync(path.join(tmp, "src"))).toBe(true)
-  })
-
-  it("preserves existing components.json on re-init (non-TTY defaults to no)", async () => {
-    const customConfig = {
-      globalCss: "app/styles.css",
-      componentsUi: "app/ui",
-      lib: "app/utils",
-    }
-    writeConfig(tmp, customConfig)
-
-    await init()
-
-    const loaded = loadConfig(tmp)
-    expect(loaded.globalCss).toBe("app/styles.css")
-    expect(loaded.componentsUi).toBe("app/ui")
-    expect(loaded.lib).toBe("app/utils")
-  })
-})
-
-// ─── add command ────────────────────────────────────────────────────────────
-
-describe("add command", () => {
-  let tmp
-  let originalCwd
-  let originalFetch
-
-  beforeEach(() => {
-    tmp = makeTmpDir()
-    originalCwd = process.cwd()
-    process.chdir(tmp)
-    originalFetch = globalThis.fetch
-
-    // Create package.json
-    fs.writeFileSync(
-      path.join(tmp, "package.json"),
-      JSON.stringify({ name: "test-project", dependencies: {} }),
-      "utf8"
-    )
-  })
-
-  afterEach(() => {
-    process.chdir(originalCwd)
-    globalThis.fetch = originalFetch
-    cleanTmpDir(tmp)
-  })
-
-  it("creates utils.ts if missing", async () => {
-    // Mock fetch for registry and component file
-    globalThis.fetch = vi.fn(async (url) => {
-      if (url.endsWith("registry.json")) {
-        return {
-          ok: true,
-          json: async () => ({
-            button: {
-              files: ["src/components/ui/button.tsx"],
-              dependencies: [],
-            },
-          }),
-        }
-      }
-      if (url.endsWith("button.tsx")) {
-        return {
-          ok: true,
-          text: async () => 'export function Button() { return null }',
-        }
-      }
-      return { ok: false, statusText: "Not Found" }
-    })
-
-    await add("button")
-
-    const utilsPath = path.join(tmp, DEFAULT_CONFIG.lib, "utils.ts")
-    expect(fs.existsSync(utilsPath)).toBe(true)
-    expect(fs.readFileSync(utilsPath, "utf8")).toBe(UTILS_CONTENT)
-  })
-
-  it("downloads component file to the correct directory", async () => {
-    const componentCode = `import React from "react"\nexport function Button() { return null }`
-
-    globalThis.fetch = vi.fn(async (url) => {
-      if (url.endsWith("registry.json")) {
-        return {
-          ok: true,
-          json: async () => ({
-            button: {
-              files: ["src/components/ui/button.tsx"],
-              dependencies: [],
-            },
-          }),
-        }
-      }
-      if (url.endsWith("button.tsx")) {
-        return { ok: true, text: async () => componentCode }
-      }
-      return { ok: false, statusText: "Not Found" }
-    })
-
-    await add("button")
-
-    const dest = path.join(tmp, DEFAULT_CONFIG.componentsUi, "button.tsx")
-    expect(fs.existsSync(dest)).toBe(true)
-    expect(fs.readFileSync(dest, "utf8")).toBe(componentCode)
-  })
-
-  it("uses paths from components.json if present", async () => {
-    const customConfig = {
-      globalCss: "app/global.css",
-      componentsUi: "app/ui",
-      lib: "app/lib",
-    }
-    writeConfig(tmp, customConfig)
-
-    globalThis.fetch = vi.fn(async (url) => {
-      if (url.endsWith("registry.json")) {
-        return {
-          ok: true,
-          json: async () => ({
-            card: { files: ["src/components/ui/card.tsx"], dependencies: [] },
-          }),
-        }
-      }
-      if (url.endsWith("card.tsx")) {
-        return { ok: true, text: async () => "export function Card() {}" }
-      }
-      return { ok: false, statusText: "Not Found" }
-    })
-
-    await add("card")
-
-    const dest = path.join(tmp, "app", "ui", "card.tsx")
-    expect(fs.existsSync(dest)).toBe(true)
-  })
-
-  it("throws when registry fetch fails", async () => {
-    globalThis.fetch = vi.fn(async () => ({
-      ok: false,
-      statusText: "Internal Server Error",
-    }))
-
-    await expect(add("button")).rejects.toThrow(/Failed to fetch registry/)
-  })
-
-  it("throws when registry is not a valid object", async () => {
-    globalThis.fetch = vi.fn(async () => ({
-      ok: true,
-      json: async () => [1, 2, 3],
-    }))
-
-    await expect(add("button")).rejects.toThrow(/not a valid object/)
-  })
-
-  it("handles component with multiple files", async () => {
-    globalThis.fetch = vi.fn(async (url) => {
-      if (url.endsWith("registry.json")) {
-        return {
-          ok: true,
-          json: async () => ({
-            dialog: {
-              files: [
-                "src/components/ui/dialog.tsx",
-                "src/components/ui/dialog-overlay.tsx",
-              ],
-              dependencies: [],
-            },
-          }),
-        }
-      }
-      if (url.endsWith("dialog.tsx")) {
-        return { ok: true, text: async () => "// dialog" }
-      }
-      if (url.endsWith("dialog-overlay.tsx")) {
-        return { ok: true, text: async () => "// overlay" }
-      }
-      return { ok: false, statusText: "Not Found" }
-    })
-
-    await add("dialog")
-
-    const uiDir = path.join(tmp, DEFAULT_CONFIG.componentsUi)
-    expect(fs.existsSync(path.join(uiDir, "dialog.tsx"))).toBe(true)
-    expect(fs.existsSync(path.join(uiDir, "dialog-overlay.tsx"))).toBe(true)
-  })
-
-  it("continues when a single file download fails", async () => {
-    globalThis.fetch = vi.fn(async (url) => {
-      if (url.endsWith("registry.json")) {
-        return {
-          ok: true,
-          json: async () => ({
-            multi: {
-              files: ["src/components/ui/a.tsx", "src/components/ui/b.tsx"],
-              dependencies: [],
-            },
-          }),
-        }
-      }
-      if (url.endsWith("a.tsx")) {
-        return { ok: false, statusText: "Not Found" }
-      }
-      if (url.endsWith("b.tsx")) {
-        return { ok: true, text: async () => "// b component" }
-      }
-      return { ok: false, statusText: "Not Found" }
-    })
-
-    await add("multi")
-
-    const uiDir = path.join(tmp, DEFAULT_CONFIG.componentsUi)
-    expect(fs.existsSync(path.join(uiDir, "a.tsx"))).toBe(false)
-    expect(fs.existsSync(path.join(uiDir, "b.tsx"))).toBe(true)
-  })
-})