@zenithbuild/cli 0.4.2

package/src/main.ts

@@ -0,0 +1,101 @@
+/**
+ * @zenithbuild/cli - Shared CLI Execution Logic
+ */
+
+import process from 'node:process'
+import { getCommand, showHelp, placeholderCommands } from './commands/index'
+import * as logger from './utils/logger'
+import { execSync } from 'node:child_process'
+
+/**
+ * Check if Bun is available in the environment
+ */
+function checkBun() {
+    try {
+        execSync('bun --version', { stdio: 'pipe' })
+        return true
+    } catch {
+        return false
+    }
+}
+
+export interface CLIOptions {
+    defaultCommand?: string
+}
+
+/**
+ * Main CLI execution entry point
+ */
+export async function runCLI(options: CLIOptions = {}) {
+    // 1. Check for Bun
+    if (!checkBun()) {
+        logger.error('Bun is required to run Zenith.')
+        logger.info('Please install Bun: https://bun.sh/install')
+        process.exit(1)
+    }
+
+    const args = process.argv.slice(2)
+    const VERSION = '0.3.0'
+
+    // 2. Handle global version flag
+    if (args.includes('--version') || args.includes('-v')) {
+        console.log(`Zenith CLI v${VERSION}`)
+        process.exit(0)
+    }
+
+    // Determine command name: either from args or default (for aliases)
+    let commandName = args[0]
+    let commandArgs = args.slice(1)
+
+    if (options.defaultCommand) {
+        if (!commandName || commandName.startsWith('-')) {
+            commandName = options.defaultCommand
+            commandArgs = args
+        }
+    }
+
+    // Handle help
+    if (!commandName || ((commandName === '--help' || commandName === '-h') && !options.defaultCommand)) {
+        showHelp()
+        process.exit(0)
+    }
+
+    // Parse options (--key value format) for internal use if needed
+    const cliOptions: Record<string, string> = {}
+    for (let i = 0; i < commandArgs.length; i++) {
+        const arg = commandArgs[i]!
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2)
+            const value = commandArgs[i + 1]
+            if (value && !value.startsWith('--')) {
+                cliOptions[key] = value
+                i++
+            } else {
+                cliOptions[key] = 'true'
+            }
+        }
+    }
+
+    // Check for placeholder commands
+    if (placeholderCommands.includes(commandName)) {
+        logger.warn(`Command "${commandName}" is not yet implemented.`)
+        logger.info('This feature is planned for a future release.')
+        process.exit(0)
+    }
+
+    const command = getCommand(commandName)
+
+    if (!command) {
+        logger.error(`Unknown command: ${commandName}`)
+        showHelp()
+        process.exit(1)
+    }
+
+    try {
+        await command!.run(commandArgs, cliOptions)
+    } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err)
+        logger.error(message)
+        process.exit(1)
+    }
+}

package/src/utils/branding.ts

@@ -0,0 +1,178 @@
+/**
+ * Zenith CLI Branding
+ * 
+ * ASCII art logo, colors, animations, and styled output
+ */
+
+import pc from 'picocolors'
+
+// Brand colors
+export const colors = {
+    primary: pc.blue,
+    secondary: pc.cyan,
+    success: pc.green,
+    warning: pc.yellow,
+    error: pc.red,
+    muted: pc.gray,
+    bold: pc.bold,
+    dim: pc.dim
+}
+
+// ASCII Zenith logo
+export const LOGO = `
+${pc.cyan('╔═══════════════════════════════════════════════════════════╗')}
+${pc.cyan('║')}                                                           ${pc.cyan('║')}
+${pc.cyan('║')}   ${pc.bold(pc.blue('███████╗'))}${pc.bold(pc.cyan('███████╗'))}${pc.bold(pc.blue('███╗   ██╗'))}${pc.bold(pc.cyan('██╗'))}${pc.bold(pc.blue('████████╗'))}${pc.bold(pc.cyan('██╗  ██╗'))}   ${pc.cyan('║')}
+${pc.cyan('║')}   ${pc.bold(pc.blue('╚══███╔╝'))}${pc.bold(pc.cyan('██╔════╝'))}${pc.bold(pc.blue('████╗  ██║'))}${pc.bold(pc.cyan('██║'))}${pc.bold(pc.blue('╚══██╔══╝'))}${pc.bold(pc.cyan('██║  ██║'))}   ${pc.cyan('║')}
+${pc.cyan('║')}   ${pc.bold(pc.blue('  ███╔╝ '))}${pc.bold(pc.cyan('█████╗  '))}${pc.bold(pc.blue('██╔██╗ ██║'))}${pc.bold(pc.cyan('██║'))}${pc.bold(pc.blue('   ██║   '))}${pc.bold(pc.cyan('███████║'))}   ${pc.cyan('║')}
+${pc.cyan('║')}   ${pc.bold(pc.blue(' ███╔╝  '))}${pc.bold(pc.cyan('██╔══╝  '))}${pc.bold(pc.blue('██║╚██╗██║'))}${pc.bold(pc.cyan('██║'))}${pc.bold(pc.blue('   ██║   '))}${pc.bold(pc.cyan('██╔══██║'))}   ${pc.cyan('║')}
+${pc.cyan('║')}   ${pc.bold(pc.blue('███████╗'))}${pc.bold(pc.cyan('███████╗'))}${pc.bold(pc.blue('██║ ╚████║'))}${pc.bold(pc.cyan('██║'))}${pc.bold(pc.blue('   ██║   '))}${pc.bold(pc.cyan('██║  ██║'))}   ${pc.cyan('║')}
+${pc.cyan('║')}   ${pc.bold(pc.blue('╚══════╝'))}${pc.bold(pc.cyan('╚══════╝'))}${pc.bold(pc.blue('╚═╝  ╚═══╝'))}${pc.bold(pc.cyan('╚═╝'))}${pc.bold(pc.blue('   ╚═╝   '))}${pc.bold(pc.cyan('╚═╝  ╚═╝'))}   ${pc.cyan('║')}
+${pc.cyan('║')}                                                           ${pc.cyan('║')}
+${pc.cyan('║')}       ${pc.dim('The Modern Reactive Web Framework')}                  ${pc.cyan('║')}
+${pc.cyan('║')}                                                           ${pc.cyan('║')}
+${pc.cyan('╚═══════════════════════════════════════════════════════════╝')}
+`
+
+// Compact logo for smaller spaces
+export const LOGO_COMPACT = `
+  ${pc.bold(pc.blue('⚡'))} ${pc.bold(pc.cyan('ZENITH'))} ${pc.dim('- Modern Reactive Framework')}
+`
+
+// Spinner frames for animations
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+export class Spinner {
+    private interval: ReturnType<typeof setInterval> | null = null
+    private frameIndex = 0
+    private message: string
+
+    constructor(message: string) {
+        this.message = message
+    }
+
+    start() {
+        this.interval = setInterval(() => {
+            process.stdout.write(`\r${pc.cyan(spinnerFrames[this.frameIndex])} ${this.message}`)
+            this.frameIndex = (this.frameIndex + 1) % spinnerFrames.length
+        }, 80)
+    }
+
+    stop(finalMessage?: string) {
+        if (this.interval) {
+            clearInterval(this.interval)
+            this.interval = null
+        }
+        process.stdout.write('\r' + ' '.repeat(this.message.length + 5) + '\r')
+        if (finalMessage) {
+            console.log(finalMessage)
+        }
+    }
+
+    succeed(message: string) {
+        this.stop(`${pc.green('✓')} ${message}`)
+    }
+
+    fail(message: string) {
+        this.stop(`${pc.red('✗')} ${message}`)
+    }
+}
+
+// Styled output functions
+export function showLogo() {
+    console.log(LOGO)
+}
+
+export function showCompactLogo() {
+    console.log(LOGO_COMPACT)
+}
+
+export function header(text: string) {
+    console.log(`\n${pc.bold(pc.cyan('▸'))} ${pc.bold(text)}\n`)
+}
+
+export function success(text: string) {
+    console.log(`${pc.green('✓')} ${text}`)
+}
+
+export function error(text: string) {
+    console.log(`${pc.red('✗')} ${text}`)
+}
+
+export function warn(text: string) {
+    console.log(`${pc.yellow('⚠')} ${text}`)
+}
+
+export function info(text: string) {
+    console.log(`${pc.blue('ℹ')} ${text}`)
+}
+
+export function step(num: number, text: string) {
+    console.log(`${pc.dim(`[${num}]`)} ${text}`)
+}
+
+export function highlight(text: string): string {
+    return pc.cyan(text)
+}
+
+export function dim(text: string): string {
+    return pc.dim(text)
+}
+
+export function bold(text: string): string {
+    return pc.bold(text)
+}
+
+// Animated intro (optional)
+export async function showIntro() {
+    console.clear()
+    showLogo()
+    await sleep(300)
+}
+
+function sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+// Next steps box
+export function showNextSteps(projectName: string) {
+    console.log(`
+${pc.cyan('┌─────────────────────────────────────────────────────────┐')}
+${pc.cyan('│')}                                                         ${pc.cyan('│')}
+${pc.cyan('│')}   ${pc.green('✨')} ${pc.bold('Your Zenith app is ready!')}                         ${pc.cyan('│')}
+${pc.cyan('│')}                                                         ${pc.cyan('│')}
+${pc.cyan('│')}   ${pc.dim('Next steps:')}                                          ${pc.cyan('│')}
+${pc.cyan('│')}                                                         ${pc.cyan('│')}
+${pc.cyan('│')}   ${pc.cyan('$')} ${pc.bold(`cd ${projectName}`)}${' '.repeat(Math.max(0, 40 - projectName.length))}${pc.cyan('│')}
+${pc.cyan('│')}   ${pc.cyan('$')} ${pc.bold('bun run dev')}                                       ${pc.cyan('│')}
+${pc.cyan('│')}                                                         ${pc.cyan('│')}
+${pc.cyan('│')}   ${pc.dim('Then open')} ${pc.underline(pc.blue('http://localhost:3000'))}                  ${pc.cyan('│')}
+${pc.cyan('│')}                                                         ${pc.cyan('│')}
+${pc.cyan('└─────────────────────────────────────────────────────────┘')}
+`)
+}
+
+/**
+ * Show dev server startup panel
+ */
+export function showServerPanel(options: {
+    project: string,
+    pages: string,
+    url: string,
+    hmr: boolean,
+    mode: string
+}) {
+    console.clear()
+    console.log(LOGO_COMPACT)
+    console.log(`${pc.cyan('────────────────────────────────────────────────────────────')}`)
+    console.log(` ${pc.magenta('🟣 Zenith Dev Server')}`)
+    console.log(`${pc.cyan('────────────────────────────────────────────────────────────')}`)
+    console.log(` ${pc.bold('Project:')}  ${pc.dim(options.project)}`)
+    console.log(` ${pc.bold('Pages:')}    ${pc.dim(options.pages)}`)
+    console.log(` ${pc.bold('Mode:')}     ${pc.cyan(options.mode)} ${pc.dim(`(${options.hmr ? 'HMR enabled' : 'HMR disabled'})`)}`)
+    console.log(`${pc.cyan('────────────────────────────────────────────────────────────')}`)
+    console.log(` ${pc.bold('Server:')}   ${pc.cyan(pc.underline(options.url))} ${pc.dim('(clickable)')}`)
+    console.log(` ${pc.bold('Hot Reload:')} ${options.hmr ? pc.green('Enabled ✅') : pc.red('Disabled ✗')}`)
+    console.log(`${pc.cyan('────────────────────────────────────────────────────────────')}`)
+    console.log(` ${pc.dim('Press Ctrl+C to stop')}\n`)
+}

package/src/utils/logger.ts

@@ -0,0 +1,46 @@
+/**
+ * @zenithbuild/cli - Logger Utility
+ * 
+ * Colored console output for CLI feedback
+ */
+
+import pc from 'picocolors'
+
+export function log(message: string): void {
+    console.log(`${pc.cyan('[zenith]')} ${message}`)
+}
+
+export function success(message: string): void {
+    console.log(`${pc.green('✓')} ${message}`)
+}
+
+export function warn(message: string): void {
+    console.log(`${pc.yellow('⚠')} ${message}`)
+}
+
+export function error(message: string): void {
+    console.error(`${pc.red('✗')} ${message}`)
+}
+
+export function info(message: string): void {
+    console.log(`${pc.blue('ℹ')} ${message}`)
+}
+
+export function header(title: string): void {
+    console.log(`\n${pc.bold(pc.cyan(title))}\n`)
+}
+
+export function hmr(type: 'CSS' | 'Page' | 'Layout' | 'Content', path: string): void {
+    console.log(`${pc.magenta('[HMR]')} ${pc.bold(type)} updated: ${pc.dim(path)}`)
+}
+
+export function route(method: string, path: string, status: number, totalMs: number, compileMs: number, renderMs: number): void {
+    const statusColor = status < 400 ? pc.green : pc.red
+    const timeColor = totalMs > 1000 ? pc.yellow : pc.gray
+
+    console.log(
+        `${pc.bold(method)} ${pc.cyan(path.padEnd(15))} ` +
+        `${statusColor(status)} ${pc.dim('in')} ${timeColor(`${totalMs}ms`)} ` +
+        `${pc.dim(`(compile: ${compileMs}ms, render: ${renderMs}ms)`)}`
+    )
+}

package/src/utils/plugin-manager.ts

@@ -0,0 +1,114 @@
+/**
+ * @zenithbuild/cli - Plugin Manager
+ * 
+ * Manages zenith.plugins.json for plugin registration
+ */
+
+import fs from 'fs'
+import path from 'path'
+import { findProjectRoot } from './project'
+import * as logger from './logger'
+
+export interface PluginConfig {
+    name: string
+    installedAt: string
+    options?: Record<string, unknown>
+}
+
+export interface PluginsFile {
+    plugins: PluginConfig[]
+}
+
+const PLUGINS_FILE = 'zenith.plugins.json'
+
+/**
+ * Get path to plugins file
+ */
+function getPluginsPath(): string {
+    const root = findProjectRoot()
+    if (!root) {
+        throw new Error('Not in a Zenith project')
+    }
+    return path.join(root, PLUGINS_FILE)
+}
+
+/**
+ * Read plugins file
+ */
+export function readPlugins(): PluginsFile {
+    const pluginsPath = getPluginsPath()
+
+    if (!fs.existsSync(pluginsPath)) {
+        return { plugins: [] }
+    }
+
+    try {
+        return JSON.parse(fs.readFileSync(pluginsPath, 'utf-8'))
+    } catch {
+        return { plugins: [] }
+    }
+}
+
+/**
+ * Write plugins file
+ */
+function writePlugins(data: PluginsFile): void {
+    const pluginsPath = getPluginsPath()
+    fs.writeFileSync(pluginsPath, JSON.stringify(data, null, 2))
+}
+
+/**
+ * Add a plugin to the registry
+ */
+export function addPlugin(name: string, options?: Record<string, unknown>): boolean {
+    const data = readPlugins()
+
+    // Check if already installed
+    if (data.plugins.some(p => p.name === name)) {
+        logger.warn(`Plugin "${name}" is already registered`)
+        return false
+    }
+
+    data.plugins.push({
+        name,
+        installedAt: new Date().toISOString(),
+        options
+    })
+
+    writePlugins(data)
+    logger.success(`Added plugin "${name}"`)
+    return true
+}
+
+/**
+ * Remove a plugin from the registry
+ */
+export function removePlugin(name: string): boolean {
+    const data = readPlugins()
+    const initialLength = data.plugins.length
+
+    data.plugins = data.plugins.filter(p => p.name !== name)
+
+    if (data.plugins.length === initialLength) {
+        logger.warn(`Plugin "${name}" is not registered`)
+        return false
+    }
+
+    writePlugins(data)
+    logger.success(`Removed plugin "${name}"`)
+    return true
+}
+
+/**
+ * List all registered plugins
+ */
+export function listPlugins(): PluginConfig[] {
+    return readPlugins().plugins
+}
+
+/**
+ * Check if a plugin is registered
+ */
+export function hasPlugin(name: string): boolean {
+    return readPlugins().plugins.some(p => p.name === name)
+}

package/src/utils/project.ts

@@ -0,0 +1,77 @@
+/**
+ * @zenithbuild/cli - Project Utility
+ * 
+ * Detects Zenith project root and configuration
+ */
+
+import fs from 'fs'
+import path from 'path'
+
+export interface ZenithProject {
+    root: string
+    pagesDir: string
+    distDir: string
+    hasZenithDeps: boolean
+}
+
+/**
+ * Find the project root by looking for package.json with @zenith dependencies
+ */
+export function findProjectRoot(startDir: string = process.cwd()): string | null {
+    let current = startDir
+
+    while (current !== path.dirname(current)) {
+        const pkgPath = path.join(current, 'package.json')
+
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+
+                // Check for any @zenithbuild/* or @zenithbuild/* dependency
+                const hasZenith = Object.keys(deps).some(d => d.startsWith('@zenithbuild/') || d.startsWith('@zenithbuild/'))
+                if (hasZenith) {
+                    return current
+                }
+            } catch {
+                // Invalid JSON, skip
+            }
+        }
+
+        current = path.dirname(current)
+    }
+
+    return null
+}
+
+/**
+ * Get project configuration
+ */
+export function getProject(cwd: string = process.cwd()): ZenithProject | null {
+    const root = findProjectRoot(cwd)
+    if (!root) return null
+
+    // Support both app/ and src/ directory structures
+    let appDir = path.join(root, 'app')
+    if (!fs.existsSync(appDir)) {
+        appDir = path.join(root, 'src')
+    }
+
+    return {
+        root,
+        pagesDir: path.join(appDir, 'pages'),
+        distDir: path.join(appDir, 'dist'),
+        hasZenithDeps: true
+    }
+}
+
+/**
+ * Ensure we're in a Zenith project
+ */
+export function requireProject(cwd: string = process.cwd()): ZenithProject {
+    const project = getProject(cwd)
+    if (!project) {
+        throw new Error('Not in a Zenith project. Run this command from a directory with @zenithbuild/* dependencies.')
+    }
+    return project
+}