@rokkit/cli 1.0.0-next.137 → 1.0.0-next.139

package/dist/src/doctor.d.ts

@@ -21,4 +21,4 @@ export function runChecks(fs: {
  */
 export function doctor(opts?: {
     fix?: boolean;
-}): Promise<void>;
+}): void;

package/package.json

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

package/src/doctor.js

@@ -4,33 +4,32 @@ import { resolve } from 'path'
 import { generateUnoConfig, generateAppCssImports, generateInitScript } from './init.js'
 
 /**
- * Run all doctor checks against the given filesystem adapter.
- * @param {{ exists: (p: string) => boolean, read: (p: string) => string, resolve: (p: string) => string }} fs
- * @returns {Array<{ id: string, label: string, status: 'pass'|'fail', fixable: boolean, fix: string, autoFix?: string }>}
+ * Check config file existence
+ * @param {Object} fs
+ * @returns {{ id: string, label: string, status: string, fixable: boolean, fix: string, autoFix: string }}
  */
-export function runChecks(fs) {
-	const checks = []
-
-	// 1. rokkit.config.js exists
+function checkConfig(fs) {
 	const configExists = fs.exists(fs.resolve('rokkit.config.js'))
-	checks.push({
+	return {
 		id: 'config-exists',
 		label: 'rokkit.config.js exists',
 		status: configExists ? 'pass' : 'fail',
 		fixable: true,
 		fix: 'Run `rokkit init` to generate config',
 		autoFix: 'generate-config'
-	})
+	}
+}
 
-	// 2. uno.config.js uses presetRokkit
+/**
+ * Check uno.config.js uses presetRokkit
+ * @param {Object} fs
+ * @returns {Object}
+ */
+function checkUnoPreset(fs) {
 	const unoPath = fs.resolve('uno.config.js')
 	const unoExists = fs.exists(unoPath)
-	let unoUsesPreset = false
-	if (unoExists) {
-		const unoContent = fs.read(unoPath)
-		unoUsesPreset = unoContent.includes('presetRokkit')
-	}
-	checks.push({
+	const unoUsesPreset = unoExists && fs.read(unoPath).includes('presetRokkit')
+	return {
 		id: 'uno-uses-preset',
 		label: 'uno.config.js uses presetRokkit()',
 		status: unoUsesPreset ? 'pass' : 'fail',
@@ -38,43 +37,56 @@ export function runChecks(fs) {
 		fix: unoExists
 			? `Replace uno.config.js contents with:\n${generateUnoConfig()}`
 			: `Create uno.config.js with:\n${generateUnoConfig()}`
-	})
+	}
+}
 
-	// 3. app.css has theme imports
+/**
+ * Check app.css has theme imports
+ * @param {Object} fs
+ * @returns {Object}
+ */
+function checkCssImports(fs) {
 	const cssPath = fs.resolve('src/app.css')
 	const cssExists = fs.exists(cssPath)
-	let cssHasBase = false
-	if (cssExists) {
-		const css = fs.read(cssPath)
-		cssHasBase = css.includes('@rokkit/themes/dist/base')
-	}
-	checks.push({
+	const cssHasBase = cssExists && fs.read(cssPath).includes('@rokkit/themes/dist/base')
+	return {
 		id: 'css-imports',
 		label: 'app.css has theme imports',
 		status: cssHasBase ? 'pass' : 'fail',
 		fixable: true,
 		fix: 'Append theme imports to src/app.css',
 		autoFix: 'patch-css'
-	})
+	}
+}
 
-	// 4. app.html has init script
+/**
+ * Check app.html has init script
+ * @param {Object} fs
+ * @returns {Object}
+ */
+function checkHtmlScript(fs) {
 	const htmlPath = fs.resolve('src/app.html')
 	const htmlExists = fs.exists(htmlPath)
-	let htmlHasScript = false
-	if (htmlExists) {
-		const html = fs.read(htmlPath)
-		htmlHasScript = html.includes('rokkit-theme') || html.includes('data-mode')
-	}
-	checks.push({
+	const htmlHasScript =
+		htmlExists &&
+		(fs.read(htmlPath).includes('rokkit-theme') || fs.read(htmlPath).includes('data-mode'))
+	return {
 		id: 'html-init-script',
 		label: 'app.html has theme init script',
 		status: htmlHasScript ? 'pass' : 'fail',
 		fixable: true,
 		fix: 'Add flash-prevention script to src/app.html',
 		autoFix: 'patch-html'
-	})
+	}
+}
 
-	return checks
+/**
+ * Run all doctor checks against the given filesystem adapter.
+ * @param {{ exists: (p: string) => boolean, read: (p: string) => string, resolve: (p: string) => string }} 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)]
 }
 
 /**
@@ -89,98 +101,165 @@ function createFsAdapter(cwd) {
 	}
 }
 
+/**
+ * Apply the generate-config fix
+ * @param {string} cwd
+ * @param {string} label
+ */
+function applyGenerateConfig(cwd, label) {
+	const configPath = resolve(cwd, 'rokkit.config.js')
+	writeFileSync(configPath, 'export default {}\n')
+	console.info(`  Fixed: ${label}`)
+}
+
+/**
+ * Apply the patch-css fix
+ * @param {string} cwd
+ * @param {string} label
+ */
+function applyPatchCss(cwd, label) {
+	const cssPath = resolve(cwd, 'src/app.css')
+	const imports = generateAppCssImports(['rokkit'])
+	if (existsSync(cssPath)) {
+		const existing = readFileSync(cssPath, 'utf-8')
+		const missing = imports.filter((line) => !existing.includes(line))
+		if (missing.length > 0) writeFileSync(cssPath, `${missing.join('\n')}\n${existing}`)
+	} else {
+		writeFileSync(cssPath, `${imports.join('\n')}\n`)
+	}
+	console.info(`  Fixed: ${label}`)
+}
+
+/**
+ * Apply the patch-html fix
+ * @param {string} cwd
+ * @param {string} label
+ * @returns {boolean} whether fix was applied
+ */
+function applyPatchHtml(cwd, label) {
+	const htmlPath = resolve(cwd, 'src/app.html')
+	if (!existsSync(htmlPath)) return false
+	const html = readFileSync(htmlPath, 'utf-8')
+	const script = generateInitScript('manual', 'rokkit-theme')
+	if (!script || html.includes('rokkit-theme')) return false
+	const patched = html.replace(/(<body[^>]*>)/, `$1\n${script}`)
+	writeFileSync(htmlPath, patched)
+	console.info(`  Fixed: ${label}`)
+	return true
+}
+
+/** @type {Record<string, (cwd: string, label: string) => boolean|void>} */
+const FIX_HANDLERS = {
+	'generate-config': (cwd, label) => { applyGenerateConfig(cwd, label); return true },
+	'patch-css': (cwd, label) => { applyPatchCss(cwd, label); return true },
+	'patch-html': (cwd, label) => applyPatchHtml(cwd, label)
+}
+
+/**
+ * @param {number} fixed
+ * @param {{ status: string, fixable: boolean, autoFix?: string, label: string }} check
+ * @param {string} cwd
+ * @returns {number}
+ */
+function applyCheckFix(fixed, check, cwd) {
+	if (check.status !== 'fail' || !check.fixable) return fixed
+	const handler = FIX_HANDLERS[check.autoFix]
+	return handler && handler(cwd, check.label) ? fixed + 1 : fixed
+}
+
 /**
  * Auto-fix failed checks that are marked fixable.
- * @param {Array<{ id: string, status: string, fixable: boolean, autoFix?: string }>} checks
+ * @param {Array<{ id: string, status: string, fixable: boolean, autoFix?: string, label: string }>} checks
  * @param {string} cwd
  * @returns {number} number of fixed items
  */
 function autoFix(checks, cwd) {
-	let fixed = 0
+	return checks.reduce((fixed, check) => applyCheckFix(fixed, check, cwd), 0)
+}
 
+/**
+ * Print fix hints for failing checks
+ * @param {Array} checks
+ */
+function printFixHints(checks) {
 	for (const check of checks) {
-		if (check.status !== 'fail' || !check.fixable) continue
-
-		if (check.autoFix === 'generate-config') {
-			const configPath = resolve(cwd, 'rokkit.config.js')
-			writeFileSync(configPath, 'export default {}\n')
-			console.info(`  Fixed: ${check.label}`)
-			fixed++
-		}
-
-		if (check.autoFix === 'patch-css') {
-			const cssPath = resolve(cwd, 'src/app.css')
-			const imports = generateAppCssImports(['rokkit'])
-			if (existsSync(cssPath)) {
-				const existing = readFileSync(cssPath, 'utf-8')
-				const missing = imports.filter((line) => !existing.includes(line))
-				if (missing.length > 0) {
-					writeFileSync(cssPath, `${missing.join('\n')}\n${existing}`)
-				}
-			} else {
-				writeFileSync(cssPath, `${imports.join('\n')}\n`)
-			}
-			console.info(`  Fixed: ${check.label}`)
-			fixed++
+		if (check.status === 'fail') {
+			console.info(`         ${check.fixable ? '(auto-fixable) ' : ''}${check.fix}`)
 		}
+	}
+}
 
-		if (check.autoFix === 'patch-html') {
-			const htmlPath = resolve(cwd, 'src/app.html')
-			if (existsSync(htmlPath)) {
-				const html = readFileSync(htmlPath, 'utf-8')
-				const script = generateInitScript('manual', 'rokkit-theme')
-				if (script && !html.includes('rokkit-theme')) {
-					const patched = html.replace(/(<body[^>]*>)/, `$1\n${script}`)
-					writeFileSync(htmlPath, patched)
-					console.info(`  Fixed: ${check.label}`)
-					fixed++
-				}
-			}
+/**
+ * Print remaining manual action items
+ * @param {Array} checks
+ */
+function printManualItems(checks) {
+	for (const check of checks) {
+		if (check.status === 'fail' && !check.fixable) {
+			console.info(`  - ${check.label}: ${check.fix}`)
 		}
 	}
-
-	return fixed
 }
 
 /**
- * Interactive doctor command — validates project setup.
- * @param {{ fix?: boolean }} [opts]
+ * Count failures and print status for each check.
+ * @param {Array} checks
+ * @returns {number}
  */
-export async function doctor(opts = {}) {
-	const cwd = process.cwd()
-	const fs = createFsAdapter(cwd)
-	const checks = runChecks(fs)
-
-	console.info('Rokkit Doctor\n')
-
+function printChecks(checks) {
 	let failures = 0
 	for (const check of checks) {
 		const icon = check.status === 'pass' ? 'PASS' : 'FAIL'
 		console.info(`  ${icon}  ${check.label}`)
-		if (check.status === 'fail') {
-			failures++
-			if (!opts.fix) {
-				console.info(`         ${check.fixable ? '(auto-fixable) ' : ''}${check.fix}`)
-			}
-		}
+		if (check.status === 'fail') failures++
 	}
+	return failures
+}
 
-	if (failures > 0 && opts.fix) {
-		console.info('\nAuto-fixing...\n')
-		const fixed = autoFix(checks, cwd)
-		const remaining = failures - fixed
-		if (remaining > 0) {
-			console.info(`\n${fixed} fixed, ${remaining} require manual action:`)
-			for (const check of checks) {
-				if (check.status === 'fail' && !check.fixable) {
-					console.info(`  - ${check.label}: ${check.fix}`)
-				}
-			}
-		} else {
-			console.info(`\nAll ${fixed} issues fixed!`)
-		}
+/**
+ * Handle auto-fix flow and print results.
+ * @param {Array} checks
+ * @param {string} cwd
+ * @param {number} failures
+ */
+function handleAutoFix(checks, cwd, failures) {
+	console.info('\nAuto-fixing...\n')
+	const fixed = autoFix(checks, cwd)
+	const remaining = failures - fixed
+	if (remaining > 0) {
+		console.info(`\n${fixed} fixed, ${remaining} require manual action:`)
+		printManualItems(checks)
+	} else {
+		console.info(`\nAll ${fixed} issues fixed!`)
 	}
+}
 
+/**
+ * @param {Array} checks
+ * @param {string} cwd
+ * @param {number} failures
+ * @param {boolean} fix
+ */
+function handleResults(checks, cwd, failures, fix) {
+	if (failures === 0) return
+	if (fix) {
+		handleAutoFix(checks, cwd, failures)
+	} else {
+		printFixHints(checks)
+		process.exitCode = 1
+	}
+}
+
+/**
+ * Interactive doctor command — validates project setup.
+ * @param {{ fix?: boolean }} [opts]
+ */
+export function doctor(opts = {}) {
+	const cwd = process.cwd()
+	const checks = runChecks(createFsAdapter(cwd))
+
+	console.info('Rokkit Doctor\n')
+	const failures = printChecks(checks)
+	handleResults(checks, cwd, failures, opts.fix ?? false)
 	console.info('')
-	process.exitCode = failures > 0 && !opts.fix ? 1 : 0
 }

package/src/init.js

@@ -101,85 +101,157 @@ export function generateInitScript(switcher, storageKey = 'rokkit-theme') {
     </script>`
 }
 
+const PROMPTS_CONFIG = [
+	{
+		type: 'select',
+		name: 'palette',
+		message: 'Color palette',
+		choices: [
+			{ title: 'Default (orange/pink/sky)', value: 'default' },
+			{ title: 'Vibrant (blue/purple/sky)', value: 'vibrant' },
+			{ title: 'Seaweed (sky/green/blue)', value: 'seaweed' },
+			{ title: 'Custom', value: 'custom' }
+		]
+	},
+	{
+		type: (prev) => (prev === 'custom' ? 'text' : null),
+		name: 'primary',
+		message: 'Primary color (Tailwind palette name)',
+		initial: 'orange'
+	},
+	{
+		type: (_, values) => (values.palette === 'custom' ? 'text' : null),
+		name: 'secondary',
+		message: 'Secondary color',
+		initial: 'pink'
+	},
+	{
+		type: (_, values) => (values.palette === 'custom' ? 'text' : null),
+		name: 'accent',
+		message: 'Accent color',
+		initial: 'sky'
+	},
+	{
+		type: (_, values) => (values.palette === 'custom' ? 'text' : null),
+		name: 'surface',
+		message: 'Surface color',
+		initial: 'slate'
+	},
+	{
+		type: 'select',
+		name: 'icons',
+		message: 'Icon collections',
+		choices: [
+			{ title: 'Rokkit icons only', value: 'rokkit' },
+			{ title: 'Rokkit + custom collection', value: 'custom' }
+		]
+	},
+	{
+		type: (prev) => (prev === 'custom' ? 'text' : null),
+		name: 'iconPath',
+		message: 'Path to custom icon collection JSON',
+		initial: './static/icons/custom.json'
+	},
+	{
+		type: 'multiselect',
+		name: 'themes',
+		message: 'Theme styles',
+		choices: [
+			{ title: 'Rokkit', value: 'rokkit', selected: true },
+			{ title: 'Minimal', value: 'minimal' },
+			{ title: 'Material', value: 'material' }
+		],
+		min: 1
+	},
+	{
+		type: 'select',
+		name: 'switcher',
+		message: 'Theme switching',
+		choices: [
+			{ title: 'System only (prefers-color-scheme)', value: 'system' },
+			{ title: 'Manual (light/dark toggle)', value: 'manual' },
+			{ title: 'Full (light/dark + style variants)', value: 'full' }
+		]
+	}
+]
+
+/**
+ * Write rokkit.config.js
+ * @param {string} cwd
+ * @param {Record<string, unknown>} config
+ */
+function writeRokkitConfig(cwd, config) {
+	const configPath = resolve(cwd, 'rokkit.config.js')
+	if (existsSync(configPath)) {
+		console.warn('  rokkit.config.js already exists — skipping')
+		return
+	}
+	writeFileSync(configPath, `export default ${JSON.stringify(config, null, 2)}\n`)
+	console.info('  Created rokkit.config.js')
+}
+
+/**
+ * Write uno.config.js
+ * @param {string} cwd
+ */
+function writeUnoConfig(cwd) {
+	const unoPath = resolve(cwd, 'uno.config.js')
+	if (existsSync(unoPath)) {
+		console.warn('  uno.config.js already exists — skipping (see rokkit doctor for migration)')
+		return
+	}
+	writeFileSync(unoPath, generateUnoConfig())
+	console.info('  Created uno.config.js')
+}
+
+/**
+ * Patch or create app.css
+ * @param {string} cwd
+ * @param {string[]} cssImports
+ */
+function writeAppCss(cwd, cssImports) {
+	const appCssPath = resolve(cwd, 'src/app.css')
+	if (!existsSync(appCssPath)) {
+		writeFileSync(appCssPath, `${cssImports.join('\n')}\n`)
+		console.info('  Created src/app.css')
+		return
+	}
+	const existing = readFileSync(appCssPath, 'utf-8')
+	const missing = cssImports.filter((line) => !existing.includes(line))
+	if (missing.length > 0) {
+		writeFileSync(appCssPath, `${missing.join('\n')}\n${existing}`)
+		console.info(`  Patched app.css — added ${missing.length} imports`)
+	} else {
+		console.info('  app.css already has theme imports')
+	}
+}
+
+/**
+ * Patch app.html with init script
+ * @param {string} cwd
+ * @param {string} initScript
+ * @param {string} storageKey
+ */
+function writeAppHtml(cwd, initScript, storageKey) {
+	const appHtmlPath = resolve(cwd, 'src/app.html')
+	if (!existsSync(appHtmlPath)) return
+	const html = readFileSync(appHtmlPath, 'utf-8')
+	if (html.includes('rokkit-theme') || html.includes(storageKey)) {
+		console.info('  app.html already has init script')
+		return
+	}
+	const patched = html.replace(/(<body[^>]*>)/, `$1\n${initScript}`)
+	writeFileSync(appHtmlPath, patched)
+	console.info('  Patched app.html — added theme init script')
+}
+
 /**
  * Interactive init command — prompts the user, writes config files.
  */
 export async function init() {
 	console.info('Rokkit Init — Setting up your SvelteKit project\n')
 
-	const response = await prompts([
-		{
-			type: 'select',
-			name: 'palette',
-			message: 'Color palette',
-			choices: [
-				{ title: 'Default (orange/pink/sky)', value: 'default' },
-				{ title: 'Vibrant (blue/purple/sky)', value: 'vibrant' },
-				{ title: 'Seaweed (sky/green/blue)', value: 'seaweed' },
-				{ title: 'Custom', value: 'custom' }
-			]
-		},
-		{
-			type: (prev) => (prev === 'custom' ? 'text' : null),
-			name: 'primary',
-			message: 'Primary color (Tailwind palette name)',
-			initial: 'orange'
-		},
-		{
-			type: (_, values) => (values.palette === 'custom' ? 'text' : null),
-			name: 'secondary',
-			message: 'Secondary color',
-			initial: 'pink'
-		},
-		{
-			type: (_, values) => (values.palette === 'custom' ? 'text' : null),
-			name: 'accent',
-			message: 'Accent color',
-			initial: 'sky'
-		},
-		{
-			type: (_, values) => (values.palette === 'custom' ? 'text' : null),
-			name: 'surface',
-			message: 'Surface color',
-			initial: 'slate'
-		},
-		{
-			type: 'select',
-			name: 'icons',
-			message: 'Icon collections',
-			choices: [
-				{ title: 'Rokkit icons only', value: 'rokkit' },
-				{ title: 'Rokkit + custom collection', value: 'custom' }
-			]
-		},
-		{
-			type: (prev) => (prev === 'custom' ? 'text' : null),
-			name: 'iconPath',
-			message: 'Path to custom icon collection JSON',
-			initial: './static/icons/custom.json'
-		},
-		{
-			type: 'multiselect',
-			name: 'themes',
-			message: 'Theme styles',
-			choices: [
-				{ title: 'Rokkit', value: 'rokkit', selected: true },
-				{ title: 'Minimal', value: 'minimal' },
-				{ title: 'Material', value: 'material' }
-			],
-			min: 1
-		},
-		{
-			type: 'select',
-			name: 'switcher',
-			message: 'Theme switching',
-			choices: [
-				{ title: 'System only (prefers-color-scheme)', value: 'system' },
-				{ title: 'Manual (light/dark toggle)', value: 'manual' },
-				{ title: 'Full (light/dark + style variants)', value: 'full' }
-			]
-		}
-	])
+	const response = await prompts(PROMPTS_CONFIG)
 
 	if (response.palette === 'custom') {
 		response.customColors = {
@@ -193,56 +265,12 @@ export async function init() {
 	const config = generateConfig(response)
 	const cwd = process.cwd()
 
-	// --- rokkit.config.js ---
-	const configPath = resolve(cwd, 'rokkit.config.js')
-	if (existsSync(configPath)) {
-		console.warn('  rokkit.config.js already exists — skipping')
-	} else {
-		writeFileSync(configPath, `export default ${JSON.stringify(config, null, 2)}\n`)
-		console.info('  Created rokkit.config.js')
-	}
+	writeRokkitConfig(cwd, config)
+	writeUnoConfig(cwd)
+	writeAppCss(cwd, generateAppCssImports(config.themes))
 
-	// --- uno.config.js ---
-	const unoPath = resolve(cwd, 'uno.config.js')
-	if (existsSync(unoPath)) {
-		console.warn('  uno.config.js already exists — skipping (see rokkit doctor for migration)')
-	} else {
-		writeFileSync(unoPath, generateUnoConfig())
-		console.info('  Created uno.config.js')
-	}
-
-	// --- src/app.css ---
-	const appCssPath = resolve(cwd, 'src/app.css')
-	const cssImports = generateAppCssImports(config.themes)
-	if (existsSync(appCssPath)) {
-		const existing = readFileSync(appCssPath, 'utf-8')
-		const missing = cssImports.filter((line) => !existing.includes(line))
-		if (missing.length > 0) {
-			writeFileSync(appCssPath, `${missing.join('\n')}\n${existing}`)
-			console.info(`  Patched app.css — added ${missing.length} imports`)
-		} else {
-			console.info('  app.css already has theme imports')
-		}
-	} else {
-		writeFileSync(appCssPath, `${cssImports.join('\n')}\n`)
-		console.info('  Created src/app.css')
-	}
-
-	// --- src/app.html (theme init script) ---
 	const initScript = generateInitScript(config.switcher, config.storageKey)
-	if (initScript) {
-		const appHtmlPath = resolve(cwd, 'src/app.html')
-		if (existsSync(appHtmlPath)) {
-			const html = readFileSync(appHtmlPath, 'utf-8')
-			if (!html.includes('rokkit-theme') && !html.includes(config.storageKey)) {
-				const patched = html.replace(/(<body[^>]*>)/, `$1\n${initScript}`)
-				writeFileSync(appHtmlPath, patched)
-				console.info('  Patched app.html — added theme init script')
-			} else {
-				console.info('  app.html already has init script')
-			}
-		}
-	}
+	if (initScript) writeAppHtml(cwd, initScript, config.storageKey)
 
 	console.info('\nDone! Run `rokkit doctor` to verify your setup.')
 }