@rokkit/cli 1.0.0-next.147 → 1.0.0-next.150

package/dist/src/config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Load rokkit.config.js using injected adapter or real filesystem.
+ * Returns null (not an error) if config is absent or fails to load.
+ * @param {{ readConfig?: () => Record<string, unknown>, cwd?: string }} adapters
+ * @returns {Promise<Record<string, unknown> | null>}
+ */
+export function loadConfig(adapters: {
+    readConfig?: () => Record<string, unknown>;
+    cwd?: string;
+}): Promise<Record<string, unknown> | null>;

package/dist/src/convert.d.ts

@@ -50,7 +50,7 @@ export function getFolderNames(dir: string): string[];
  */
 export function bundleFolders(folders: string[], config: import("./types").IconBuilderOptions, opts: import("./types").FolderOptions): void;
 /**
- * Converts a folder of icons into an icon bundle
+ * Converts a folder of icons into individual SVG files
  * @param {string[]}                             folders
  * @param {import('./types').IconBuilderOptions} config
  * @param {import('./types').FolderOptions}      opts

package/dist/src/init.d.ts

@@ -1,16 +1,18 @@
-/**
- * Generate a Rokkit config object from user choices.
- * @param {{ palette: string, customColors?: Record<string, string>, icons: string, iconPath?: string, themes: string[], switcher: string }} opts
- * @returns {Record<string, unknown>}
- */
-export function generateConfig({ palette, customColors, icons, iconPath, themes, switcher }: {
-    palette: string;
-    customColors?: Record<string, string>;
-    icons: string;
-    iconPath?: string;
-    themes: string[];
-    switcher: string;
-}): Record<string, unknown>;
+export function generateConfig({ palette, customColors, icons, iconPath, themes, defaultTheme, switcher }: {
+    palette: any;
+    customColors: any;
+    icons: any;
+    iconPath: any;
+    themes: any;
+    defaultTheme: any;
+    switcher: any;
+}): {
+    colors: Record<string, unknown>;
+    themes: any;
+    defaultTheme: any;
+    switcher: any;
+    storageKey: string;
+};
 /**
  * Generate the content for uno.config.js.
  * @returns {string}
@@ -29,7 +31,7 @@ export function generateAppCssImports(themes: string[]): string[];
  * @param {string} [storageKey='rokkit-theme']
  * @returns {string | null}
  */
-export function generateInitScript(switcher: string, storageKey?: string): string | null;
+export function generateInitScript(switcher: string, storageKey?: string, defaultStyle?: string): string | null;
 /**
  * Interactive init command — prompts the user, writes config files.
  */

package/dist/src/skin.d.ts

@@ -16,31 +16,8 @@ export function addSkinToConfig(config: Record<string, unknown>, name: string):
  * @returns {string}
  */
 export function serializeConfig(config: Record<string, unknown>): string;
-/**
- * List all skins defined in rokkit.config.js.
- * @param {{
- *   readConfig?: () => Record<string, unknown>,
- *   cwd?: string
- * }} adapters
- */
-export function runSkinList(adapters?: {
-    readConfig?: () => Record<string, unknown>;
-    cwd?: string;
-}): Promise<void>;
-/**
- * Create a new skin entry in rokkit.config.js.
- * @param {string} name
- * @param {{
- *   readConfig?: () => Record<string, unknown>,
- *   writeConfig?: (config: Record<string, unknown>) => void,
- *   cwd?: string
- * }} adapters
- */
-export function runSkinCreate(name: string, adapters?: {
-    readConfig?: () => Record<string, unknown>;
-    writeConfig?: (config: Record<string, unknown>) => void;
-    cwd?: string;
-}): Promise<void>;
+export function runSkinList(adapters?: {}): Promise<void>;
+export function runSkinCreate(name: any, adapters?: {}): Promise<void>;
 /**
  * CLI entry point for `rokkit skin` subcommands.
  * @param {string} sub — 'list' | 'create'

package/dist/src/theme.d.ts

@@ -5,35 +5,8 @@
  * @returns {string}
  */
 export function generateThemeStub(name: string): string;
-/**
- * List all theme styles defined in rokkit.config.js plus any custom CSS files in src/themes/.
- * @param {{
- *   readConfig?: () => Record<string, unknown>,
- *   listFiles?: (dir: string) => string[],
- *   cwd?: string
- * }} adapters
- */
-export function runThemeList(adapters?: {
-    readConfig?: () => Record<string, unknown>;
-    listFiles?: (dir: string) => string[];
-    cwd?: string;
-}): Promise<void>;
-/**
- * Create a new custom theme CSS stub at src/themes/<name>.css.
- * @param {string} name
- * @param {{
- *   writeFile?: (path: string, content: string) => void,
- *   exists?: (path: string) => boolean,
- *   mkdir?: (dir: string) => void,
- *   cwd?: string
- * }} adapters
- */
-export function runThemeCreate(name: string, adapters?: {
-    writeFile?: (path: string, content: string) => void;
-    exists?: (path: string) => boolean;
-    mkdir?: (dir: string) => void;
-    cwd?: string;
-}): Promise<void>;
+export function runThemeList(adapters?: {}): Promise<void>;
+export function runThemeCreate(name: any, adapters?: {}): void;
 /**
  * CLI entry point for `rokkit theme` subcommands.
  * @param {string} sub — 'list' | 'create'

package/dist/src/upgrade.d.ts

@@ -23,25 +23,7 @@ export function buildInstallCommand(pm: "bun" | "pnpm" | "yarn" | "npm", package
     bin: string;
     args: string[];
 };
-/**
- * Run upgrade check and optionally apply it.
- *
- * @param {{ apply?: boolean }} opts
- * @param {{
- *   readFile?: (p: string) => string,
- *   exists?: (p: string) => boolean,
- *   fetchVersion?: (name: string) => string | null,
- *   runInstall?: (bin: string, args: string[]) => void
- * }} adapters — injectable for testing
- */
-export function runUpgrade(opts?: {
-    apply?: boolean;
-}, adapters?: {
-    readFile?: (p: string) => string;
-    exists?: (p: string) => boolean;
-    fetchVersion?: (name: string) => string | null;
-    runInstall?: (bin: string, args: string[]) => void;
-}): void;
+export function runUpgrade(opts?: {}, adapters?: {}): void;
 /**
  * CLI entry point for `rokkit upgrade`
  * @param {{ apply?: boolean }} opts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/cli",
-  "version": "1.0.0-next.147",
+  "version": "1.0.0-next.150",
   "description": "Command line utilities for icon bundling and conversion.",
   "repository": {
     "type": "git",

package/src/config.js

@@ -0,0 +1,23 @@
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+
+/**
+ * Load rokkit.config.js using injected adapter or real filesystem.
+ * Returns null (not an error) if config is absent or fails to load.
+ * @param {{ readConfig?: () => Record<string, unknown>, cwd?: string }} adapters
+ * @returns {Promise<Record<string, unknown> | null>}
+ */
+export async function loadConfig(adapters) {
+	if (adapters.readConfig) return adapters.readConfig()
+
+	const cwd = adapters.cwd ?? process.cwd()
+	const configPath = resolve(cwd, 'rokkit.config.js')
+	if (!existsSync(configPath)) return null
+
+	try {
+		const { default: config } = await import(`file://${configPath}?t=${Date.now()}`)
+		return config
+	} catch {
+		return null
+	}
+}

package/src/convert.js

@@ -172,40 +172,39 @@ export function getFolderNames(dir) {
 	}
 }
 
+function folderOpts(folder, config, opts, extra) {
+	const folderConfig = config.bundles?.[folder] || {}
+	return { target: opts.output, color: folderConfig.color || false, prefix: folder, ...extra }
+}
+
 /**
- * Converts a folder of icons into an icon bundle
  * @param {string[]} folders
  * @param {import('./types').IconBuilderOptions} config
- * @param {import('./types').FolderOptions}      opts
+ * @param {import('./types').FolderOptions} opts
+ * @param {{ fn: Function, extra?: Record<string, unknown> }} processor
  */
-export function bundleFolders(folders, config, opts) {
+function processFolders(folders, config, opts, { fn, extra = {} }) {
 	for (const folder of folders) {
-		const folderPath = path.join(opts.input, folder)
-		const folderConfig = config.bundles?.[folder] || {}
-
-		bundle(folderPath, {
-			target: opts.output,
-			color: folderConfig.color || false,
-			prefix: folder
-		})
+		fn(path.join(opts.input, folder), folderOpts(folder, config, opts, extra))
 	}
 }
+
 /**
  * Converts a folder of icons into an icon bundle
+ * @param {string[]} folders
+ * @param {import('./types').IconBuilderOptions} config
+ * @param {import('./types').FolderOptions}      opts
+ */
+export function bundleFolders(folders, config, opts) {
+	processFolders(folders, config, opts, { fn: bundle })
+}
+
+/**
+ * Converts a folder of icons into individual SVG files
  * @param {string[]}                             folders
  * @param {import('./types').IconBuilderOptions} config
  * @param {import('./types').FolderOptions}      opts
  */
 export function convertFolders(folders, config, opts) {
-	for (const folder of folders) {
-		const folderPath = path.join(opts.input, folder)
-		const folderConfig = config.bundles[folder] || {}
-
-		convert(folderPath, {
-			target: opts.output,
-			color: folderConfig.color || false,
-			prefix: folder,
-			package: config.package || {}
-		})
-	}
+	processFolders(folders, config, opts, { fn: convert, extra: { package: config.package || {} } })
 }

package/src/doctor.js

@@ -3,6 +3,11 @@ import { existsSync, readFileSync, writeFileSync } from 'fs'
 import { resolve } from 'path'
 import { generateUnoConfig, generateAppCssImports, generateInitScript } from './init.js'
 
+const KNOWN_THEMES = [
+  'rokkit', 'minimal', 'material', 'glass', 'grada-ui',
+  'shadcn', 'daisy-ui', 'bits-ui', 'carbon', 'ant-design'
+]
+
 /**
  * Check config file existence
  * @param {Object} fs
@@ -28,10 +33,11 @@ function checkConfig(fs) {
 function checkUnoPreset(fs) {
 	const unoPath = fs.resolve('uno.config.js')
 	const unoExists = fs.exists(unoPath)
-	const unoUsesPreset = unoExists && fs.read(unoPath).includes('presetRokkit')
+	const unoContent = unoExists ? fs.read(unoPath) : ''
+	const unoUsesPreset = unoContent.includes('presetRokkit') && unoContent.includes('rokkit.config')
 	return {
 		id: 'uno-uses-preset',
-		label: 'uno.config.js uses presetRokkit()',
+		label: 'uno.config.js uses presetRokkit(config)',
 		status: unoUsesPreset ? 'pass' : 'fail',
 		fixable: false,
 		fix: unoExists
@@ -48,17 +54,36 @@ function checkUnoPreset(fs) {
 function checkCssImports(fs) {
 	const cssPath = fs.resolve('src/app.css')
 	const cssExists = fs.exists(cssPath)
-	const cssHasBase = cssExists && fs.read(cssPath).includes('@rokkit/themes/dist/base')
+	const cssHasBase = cssExists && fs.read(cssPath).includes('@rokkit/themes/base.css')
 	return {
 		id: 'css-imports',
-		label: 'app.css has theme imports',
+		label: 'app.css imports @rokkit/themes/base.css',
 		status: cssHasBase ? 'pass' : 'fail',
 		fixable: true,
-		fix: 'Append theme imports to src/app.css',
+		fix: 'Append base theme import to src/app.css',
 		autoFix: 'patch-css'
 	}
 }
 
+/**
+ * Check app.css has at least one theme style
+ * @param {Object} fs
+ * @returns {Object}
+ */
+function checkCssTheme(fs) {
+	const cssPath = fs.resolve('src/app.css')
+	const cssExists = fs.exists(cssPath)
+	const css = cssExists ? fs.read(cssPath) : ''
+	const hasTheme = KNOWN_THEMES.some((t) => css.includes(`@rokkit/themes/${t}.css`))
+	return {
+		id: 'css-theme',
+		label: 'app.css has a theme style',
+		status: hasTheme ? 'pass' : 'warn',
+		fixable: false,
+		fix: `Add a theme import to src/app.css, e.g. @import '@rokkit/themes/rokkit.css'\n         Available: ${KNOWN_THEMES.join(', ')}, or use a custom theme`
+	}
+}
+
 /**
  * Check app.html has init script
  * @param {Object} fs
@@ -86,7 +111,7 @@ function checkHtmlScript(fs) {
  * @returns {Array<{ id: string, label: string, status: 'pass'|'fail', fixable: boolean, fix: string, autoFix?: string }>}
  */
 export function runChecks(fs) {
-	return [checkConfig(fs), checkUnoPreset(fs), checkCssImports(fs), checkHtmlScript(fs)]
+	return [checkConfig(fs), checkUnoPreset(fs), checkCssImports(fs), checkCssTheme(fs), checkHtmlScript(fs)]
 }
 
 /**
@@ -119,7 +144,7 @@ function applyGenerateConfig(cwd, label) {
  */
 function applyPatchCss(cwd, label) {
 	const cssPath = resolve(cwd, 'src/app.css')
-	const imports = generateAppCssImports(['rokkit'])
+	const imports = generateAppCssImports([])
 	if (existsSync(cssPath)) {
 		const existing = readFileSync(cssPath, 'utf-8')
 		const missing = imports.filter((line) => !existing.includes(line))
@@ -189,7 +214,7 @@ function autoFix(checks, cwd) {
  */
 function printFixHints(checks) {
 	for (const check of checks) {
-		if (check.status === 'fail') {
+		if (check.status === 'fail' || check.status === 'warn') {
 			console.info(`         ${check.fixable ? '(auto-fixable) ' : ''}${check.fix}`)
 		}
 	}
@@ -215,7 +240,7 @@ function printManualItems(checks) {
 function printChecks(checks) {
 	let failures = 0
 	for (const check of checks) {
-		const icon = check.status === 'pass' ? 'PASS' : 'FAIL'
+		const icon = check.status === 'pass' ? 'PASS' : check.status === 'warn' ? 'WARN' : 'FAIL'
 		console.info(`  ${icon}  ${check.label}`)
 		if (check.status === 'fail') failures++
 	}

package/src/init.js

@@ -36,13 +36,19 @@ const DEFAULT_COLORS = {
  * @param {{ palette: string, customColors?: Record<string, string>, icons: string, iconPath?: string, themes: string[], switcher: string }} opts
  * @returns {Record<string, unknown>}
  */
-export function generateConfig({ palette, customColors, icons, iconPath, themes, switcher }) {
-	const colors =
-		palette === 'custom'
-			? { ...DEFAULT_COLORS, ...customColors }
-			: { ...DEFAULT_COLORS, ...(SKIN_PRESETS[palette] || {}) }
+function resolveColors(palette, customColors) {
+	if (palette === 'custom') return { ...DEFAULT_COLORS, ...customColors }
+	return { ...DEFAULT_COLORS, ...(SKIN_PRESETS[palette] || {}) }
+}
 
-	const config = { colors, themes, switcher, storageKey: 'rokkit-theme' }
+export function generateConfig({ palette, customColors, icons, iconPath, themes, defaultTheme, switcher }) {
+	const config = {
+		colors: resolveColors(palette, customColors),
+		themes,
+		defaultTheme: defaultTheme || themes[0],
+		switcher,
+		storageKey: 'rokkit-theme'
+	}
 
 	if (icons === 'custom' && iconPath) {
 		config.icons = { custom: iconPath }
@@ -58,9 +64,10 @@ export function generateConfig({ palette, customColors, icons, iconPath, themes,
 export function generateUnoConfig() {
 	return `import { defineConfig } from 'unocss'
 import { presetRokkit } from '@rokkit/unocss'
+import config from './rokkit.config.js'
 
 export default defineConfig({
-  presets: [presetRokkit()]
+  presets: [presetRokkit(config)]
 })
 `
 }
@@ -71,9 +78,9 @@ export default defineConfig({
  * @returns {string[]}
  */
 export function generateAppCssImports(themes) {
-	const lines = ["@import '@unocss/reset/tailwind.css';", "@import '@rokkit/themes/dist/base';"]
+	const lines = ["@import '@unocss/reset/tailwind.css';", "@import '@rokkit/themes/base.css';"]
 	for (const theme of themes) {
-		lines.push(`@import '@rokkit/themes/dist/${theme}';`)
+		lines.push(`@import '@rokkit/themes/${theme}.css';`)
 	}
 	return lines
 }
@@ -85,10 +92,10 @@ export function generateAppCssImports(themes) {
  * @param {string} [storageKey='rokkit-theme']
  * @returns {string | null}
  */
-export function generateInitScript(switcher, storageKey = 'rokkit-theme') {
+export function generateInitScript(switcher, storageKey = 'rokkit-theme', defaultStyle = 'rokkit') {
 	if (switcher === 'system') return null
 
-	const setStyle = switcher === 'full' ? `b.dataset.style = t.style || 'rokkit'\n          ` : ''
+	const setStyle = switcher === 'full' ? `b.dataset.style = t.style || '${defaultStyle}'\n          ` : ''
 
 	return `    <script>
       (function () {
@@ -159,10 +166,23 @@ const PROMPTS_CONFIG = [
 		choices: [
 			{ title: 'Rokkit', value: 'rokkit', selected: true },
 			{ title: 'Minimal', value: 'minimal' },
-			{ title: 'Material', value: 'material' }
+			{ title: 'Material', value: 'material' },
+			{ title: 'Glass', value: 'glass' },
+			{ title: 'Grada UI', value: 'grada-ui' },
+			{ value: 'shadcn', title: 'shadcn', hint: 'flat borders + ring focus' },
+			{ value: 'daisy-ui', title: 'daisy-ui', hint: 'rounded-full + bold fills' },
+			{ value: 'bits-ui', title: 'bits-ui', hint: 'rounded-lg + polished' },
+			{ value: 'carbon', title: 'carbon', hint: 'square edges + enterprise' },
+			{ value: 'ant-design', title: 'ant-design', hint: 'thin borders + dense' }
 		],
 		min: 1
 	},
+	{
+		type: (prev) => (prev?.length > 1 ? 'select' : null),
+		name: 'defaultTheme',
+		message: 'Default theme style',
+		choices: (prev) => prev.map((t) => ({ title: t.charAt(0).toUpperCase() + t.slice(1), value: t }))
+	},
 	{
 		type: 'select',
 		name: 'switcher',
@@ -269,7 +289,7 @@ export async function init() {
 	writeUnoConfig(cwd)
 	writeAppCss(cwd, generateAppCssImports(config.themes))
 
-	const initScript = generateInitScript(config.switcher, config.storageKey)
+	const initScript = generateInitScript(config.switcher, config.storageKey, config.defaultTheme)
 	if (initScript) writeAppHtml(cwd, initScript, config.storageKey)
 
 	console.info('\nDone! Run `rokkit doctor` to verify your setup.')

package/src/skin.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
-import { writeFileSync, existsSync } from 'fs'
+import { writeFileSync } from 'fs'
 import { resolve } from 'path'
+import { loadConfig } from './config.js'
 
 const SKIN_TOKEN_DEFAULTS = {
 	primary: 'orange',
@@ -52,10 +53,7 @@ export function serializeConfig(config) {
  *   cwd?: string
  * }} adapters
  */
-export async function runSkinList(adapters = {}) {
-	const config = await loadConfig(adapters)
-	if (!config) return
-	const skins = config.skins ?? {}
+function printSkinNames(skins) {
 	const names = Object.keys(skins)
 	if (names.length === 0) {
 		console.info('No skins defined in rokkit.config.js.')
@@ -71,6 +69,15 @@ export async function runSkinList(adapters = {}) {
 	}
 }
 
+export async function runSkinList(adapters = {}) {
+	const config = await loadConfig(adapters)
+	if (!config) {
+		console.error('rokkit.config.js not found. Run `rokkit init` first.')
+		return
+	}
+	printSkinNames(config.skins ?? {})
+}
+
 /**
  * Create a new skin entry in rokkit.config.js.
  * @param {string} name
@@ -80,22 +87,27 @@ export async function runSkinList(adapters = {}) {
  *   cwd?: string
  * }} adapters
  */
-export async function runSkinCreate(name, adapters = {}) {
-	if (!name) {
-		console.error('Usage: rokkit skin create --name <name>')
-		return
-	}
+function validateSkinCreate(name, config) {
+	if (!name) return 'Usage: rokkit skin create --name <name>'
+	if (!config) return 'rokkit.config.js not found. Run `rokkit init` first.'
+	if (config.skins?.[name]) return `Skin "${name}" already exists in rokkit.config.js.`
+	return null
+}
 
+export async function runSkinCreate(name, adapters = {}) {
 	const config = await loadConfig(adapters)
-	if (!config) return
-
-	if (config.skins?.[name]) {
-		console.warn(`Skin "${name}" already exists in rokkit.config.js.`)
+	const error = validateSkinCreate(name, config)
+	if (error) {
+		if (error.includes('already exists')) {
+			console.warn(error)
+		} else {
+			console.error(error)
+		}
 		return
 	}
 
 	const updated = addSkinToConfig(config, name)
-	await saveConfig(updated, adapters)
+	saveConfig(updated, adapters)
 
 	console.info(`Added skin "${name}" to rokkit.config.js`)
 	console.info(
@@ -104,31 +116,12 @@ export async function runSkinCreate(name, adapters = {}) {
 	)
 }
 
-/**
- * Load rokkit.config.js using injected adapter or real filesystem.
- * @param {{ readConfig?: () => Record<string, unknown>, cwd?: string }} adapters
- * @returns {Promise<Record<string, unknown> | null>}
- */
-async function loadConfig(adapters) {
-	if (adapters.readConfig) return adapters.readConfig()
-
-	const cwd = adapters.cwd ?? process.cwd()
-	const configPath = resolve(cwd, 'rokkit.config.js')
-	if (!existsSync(configPath)) {
-		console.error('rokkit.config.js not found. Run `rokkit init` first.')
-		return null
-	}
-
-	const { default: config } = await import(`file://${configPath}?t=${Date.now()}`)
-	return config
-}
-
 /**
  * Write updated config using injected adapter or real filesystem.
  * @param {Record<string, unknown>} config
  * @param {{ writeConfig?: (config: Record<string, unknown>) => void, cwd?: string }} adapters
  */
-async function saveConfig(config, adapters) {
+function saveConfig(config, adapters) {
 	if (adapters.writeConfig) {
 		adapters.writeConfig(config)
 		return

package/src/theme.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
 import { writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs'
 import { resolve, join } from 'path'
+import { loadConfig } from './config.js'
 
 /**
  * All component names that ship with Rokkit — one CSS block will be generated for each.
@@ -62,33 +63,38 @@ export function generateThemeStub(name) {
  *   cwd?: string
  * }} adapters
  */
-export async function runThemeList(adapters = {}) {
-	const config = await loadConfig(adapters)
-	const builtIn = config?.themes ?? []
-
+function getCustomThemes(adapters) {
 	const cwd = adapters.cwd ?? process.cwd()
 	const themesDir = resolve(cwd, 'src/themes')
 	const listFiles = adapters.listFiles ?? ((dir) => (existsSync(dir) ? readdirSync(dir) : []))
-	const custom = listFiles(themesDir)
+	return listFiles(themesDir)
 		.filter((f) => f.endsWith('.css'))
 		.map((f) => f.replace(/\.css$/, ''))
+}
 
-	console.info('Rokkit Themes\n')
+function printThemeSection(label, items) {
+	if (items.length === 0) return
+	console.info(label)
+	for (const t of items) console.info(`    ${t}`)
+}
 
-	if (builtIn.length > 0) {
-		console.info('  Built-in (from @rokkit/themes):')
-		for (const t of builtIn) console.info(`    ${t}`)
-	}
-	if (custom.length > 0) {
-		console.info('\n  Custom (src/themes/):')
-		for (const t of custom) console.info(`    ${t}`)
-	}
+function printThemeList(builtIn, custom) {
+	console.info('Rokkit Themes\n')
+	printThemeSection('  Built-in (from @rokkit/themes):', builtIn)
+	printThemeSection('\n  Custom (src/themes/):', custom)
 	if (builtIn.length === 0 && custom.length === 0) {
 		console.info('  No themes found.')
 		console.info('  Run `rokkit theme create --name <name>` to scaffold a custom theme.')
 	}
 }
 
+export async function runThemeList(adapters = {}) {
+	const config = await loadConfig(adapters)
+	const builtIn = config?.themes ?? []
+	const custom = getCustomThemes(adapters)
+	printThemeList(builtIn, custom)
+}
+
 /**
  * Create a new custom theme CSS stub at src/themes/<name>.css.
  * @param {string} name
@@ -99,17 +105,22 @@ export async function runThemeList(adapters = {}) {
  *   cwd?: string
  * }} adapters
  */
-export async function runThemeCreate(name, adapters = {}) {
+function resolveThemeAdapters(adapters) {
+	return {
+		cwd: adapters.cwd ?? process.cwd(),
+		writeFile: adapters.writeFile ?? writeFileSync,
+		exists: adapters.exists ?? existsSync,
+		mkdir: adapters.mkdir ?? ((dir) => mkdirSync(dir, { recursive: true }))
+	}
+}
+
+export function runThemeCreate(name, adapters = {}) {
 	if (!name) {
 		console.error('Usage: rokkit theme create --name <name>')
 		return
 	}
 
-	const cwd = adapters.cwd ?? process.cwd()
-	const writeFile = adapters.writeFile ?? writeFileSync
-	const exists = adapters.exists ?? existsSync
-	const mkdir = adapters.mkdir ?? ((dir) => mkdirSync(dir, { recursive: true }))
-
+	const { cwd, writeFile, exists, mkdir } = resolveThemeAdapters(adapters)
 	const themesDir = resolve(cwd, 'src/themes')
 	const filePath = join(themesDir, `${name}.css`)
 
@@ -128,26 +139,6 @@ export async function runThemeCreate(name, adapters = {}) {
 	)
 }
 
-/**
- * Load rokkit.config.js using injected adapter or real filesystem.
- * Returns null (not an error) if config is absent — theme list can still show custom files.
- * @param {{ readConfig?: () => Record<string, unknown>, cwd?: string }} adapters
- */
-async function loadConfig(adapters) {
-	if (adapters.readConfig) return adapters.readConfig()
-
-	const cwd = adapters.cwd ?? process.cwd()
-	const configPath = resolve(cwd, 'rokkit.config.js')
-	if (!existsSync(configPath)) return null
-
-	try {
-		const { default: config } = await import(`file://${configPath}?t=${Date.now()}`)
-		return config
-	} catch {
-		return null
-	}
-}
-
 /**
  * CLI entry point for `rokkit theme` subcommands.
  * @param {string} sub — 'list' | 'create'
@@ -155,7 +146,7 @@ async function loadConfig(adapters) {
  */
 export async function theme(sub, opts = {}) {
 	if (sub === 'create') {
-		await runThemeCreate(opts.name)
+		runThemeCreate(opts.name)
 	} else {
 		await runThemeList()
 	}

package/src/upgrade.js

@@ -51,69 +51,92 @@ export function buildInstallCommand(pm, packages) {
  *   runInstall?: (bin: string, args: string[]) => void
  * }} adapters — injectable for testing
  */
-export function runUpgrade(opts = {}, adapters = {}) {
-	const cwd = process.cwd()
-	const readFile = adapters.readFile ?? ((p) => readFileSync(p, 'utf-8'))
-	const exists = adapters.exists ?? ((p) => existsSync(p))
-	const fetchVersion =
-		adapters.fetchVersion ??
-		((name) => {
-			try {
-				return execFileSync('npm', ['view', name, 'version'], { encoding: 'utf-8' }).trim()
-			} catch {
-				return null
-			}
-		})
-	const runInstall =
-		adapters.runInstall ??
-		((bin, args) => execFileSync(bin, args, { stdio: 'inherit' }))
+function resolveUpgradeAdapters(adapters) {
+	return {
+		readFile: adapters.readFile ?? ((p) => readFileSync(p, 'utf-8')),
+		exists: adapters.exists ?? ((p) => existsSync(p)),
+		fetchVersion:
+			adapters.fetchVersion ??
+			((name) => {
+				try {
+					return execFileSync('npm', ['view', name, 'version'], { encoding: 'utf-8' }).trim()
+				} catch {
+					return null
+				}
+			}),
+		runInstall: adapters.runInstall ?? ((bin, args) => execFileSync(bin, args, { stdio: 'inherit' }))
+	}
+}
+
+function formatPackageStatus(pkg, latest) {
+	if (!latest) return `OK   ${pkg.name}  ${pkg.current}`
+	if (latest === pkg.current) return `OK   ${pkg.name}  ${pkg.current}`
+	return `OUT  ${pkg.name}  ${pkg.current} → ${latest}`
+}
+
+function checkPackageVersion(pkg, fetchVersion, upgrades) {
+	const latest = fetchVersion(pkg.name)
+	console.info(`  ${formatPackageStatus(pkg, latest)}`)
+	if (latest && latest !== pkg.current) upgrades.push(`${pkg.name}@${latest}`)
+}
+
+function checkUpgrades(packages, fetchVersion) {
+	const upgrades = []
+	for (const pkg of packages) {
+		checkPackageVersion(pkg, fetchVersion, upgrades)
+	}
+	return upgrades
+}
+
+function applyUpgrades(upgrades, pm, apply, runInstall) {
+	const { bin, args } = buildInstallCommand(pm, upgrades)
+	const cmdStr = `${bin} ${args.join(' ')}`
+	if (apply) {
+		console.info(`\nRunning: ${cmdStr}\n`)
+		runInstall(bin, args)
+		console.info('\nUpgrade complete.')
+	} else {
+		console.info(`\n${upgrades.length} package(s) can be upgraded.`)
+		console.info(`Run with --apply to install, or manually:\n  ${cmdStr}`)
+	}
+}
 
+function loadPackages(cwd, readFile, exists) {
 	const pkgPath = resolve(cwd, 'package.json')
 	if (!exists(pkgPath)) {
 		console.error('No package.json found in current directory.')
-		return
+		return null
 	}
-
-	const pkgJson = JSON.parse(readFile(pkgPath))
-	const packages = getRokkitPackages(pkgJson)
-
+	const packages = getRokkitPackages(JSON.parse(readFile(pkgPath)))
 	if (packages.length === 0) {
 		console.info('No @rokkit/* packages found in package.json.')
-		return
+		return null
 	}
+	return packages
+}
 
+function detectPm(cwd, exists) {
 	const LOCKFILES = ['bun.lock', 'bun.lockb', 'pnpm-lock.yaml', 'yarn.lock', 'package-lock.json']
-	const presentLockfiles = LOCKFILES.filter((f) => exists(resolve(cwd, f)))
-	const pm = detectPackageManager(presentLockfiles)
+	return detectPackageManager(LOCKFILES.filter((f) => exists(resolve(cwd, f))))
+}
 
-	console.info('Rokkit Upgrade\n')
+export function runUpgrade(opts = {}, adapters = {}) {
+	const cwd = process.cwd()
+	const { readFile, exists, fetchVersion, runInstall } = resolveUpgradeAdapters(adapters)
 
-	const upgrades = []
-	for (const pkg of packages) {
-		const latest = fetchVersion(pkg.name)
-		const upToDate = latest && latest === pkg.current
-		const status = !latest ? '?' : upToDate ? 'up-to-date' : 'outdated'
-		const arrow = latest ? `${pkg.current} → ${latest}` : pkg.current
-		console.info(`  ${status === 'outdated' ? 'OUT' : 'OK '}  ${pkg.name}  ${arrow}`)
-		if (!upToDate && latest) upgrades.push(`${pkg.name}@${latest}`)
-	}
+	const packages = loadPackages(cwd, readFile, exists)
+	if (!packages) return
 
+	const pm = detectPm(cwd, exists)
+	console.info('Rokkit Upgrade\n')
+
+	const upgrades = checkUpgrades(packages, fetchVersion)
 	if (upgrades.length === 0) {
 		console.info('\nAll packages are up to date.')
 		return
 	}
 
-	const { bin, args } = buildInstallCommand(pm, upgrades)
-	const cmdStr = `${bin} ${args.join(' ')}`
-
-	if (opts.apply) {
-		console.info(`\nRunning: ${cmdStr}\n`)
-		runInstall(bin, args)
-		console.info('\nUpgrade complete.')
-	} else {
-		console.info(`\n${upgrades.length} package(s) can be upgraded.`)
-		console.info(`Run with --apply to install, or manually:\n  ${cmdStr}`)
-	}
+	applyUpgrades(upgrades, pm, opts.apply, runInstall)
 }
 
 /**