@zenithbuild/core 0.1.0 → 0.3.1

package/cli/commands/dev.ts

@@ -0,0 +1,197 @@
+/**
+ * @zenith/cli - Dev Command
+ * 
+ * Starts the development server with in-memory compilation and hot reload
+ */
+
+import path from 'path'
+import fs from 'fs'
+import { serve } from 'bun'
+import { requireProject } from '../utils/project'
+import * as logger from '../utils/logger'
+import { compileZenSource } from '../../compiler/index'
+import { discoverLayouts } from '../../compiler/discovery/layouts'
+import { processLayout } from '../../compiler/transform/layoutProcessor'
+import { generateRouteDefinition } from '../../router/manifest'
+import { generateBundleJS } from '../../runtime/bundle-generator'
+
+export interface DevOptions {
+    port?: number
+}
+
+interface CompiledPage {
+    html: string
+    script: string
+    styles: string[]
+    route: string
+    lastModified: number
+}
+
+const pageCache = new Map<string, CompiledPage>()
+
+export async function dev(options: DevOptions = {}): Promise<void> {
+    const project = requireProject()
+    const port = options.port || parseInt(process.env.PORT || '3000', 10)
+
+    // Support both app/ and src/ directory structures
+    const appDir = project.root
+    const pagesDir = project.pagesDir
+
+    logger.header('Zenith Dev Server')
+    logger.log(`Project: ${project.root}`)
+    logger.log(`Pages: ${project.pagesDir}`)
+
+    // File extensions that should be served as static assets
+    const STATIC_EXTENSIONS = new Set([
+        '.js', '.css', '.ico', '.png', '.jpg', '.jpeg', '.gif', '.svg',
+        '.webp', '.woff', '.woff2', '.ttf', '.eot', '.json', '.map'
+    ])
+
+    /**
+     * Generate the shared runtime JavaScript
+     */
+    function generateRuntimeJS(): string {
+        return generateBundleJS()
+    }
+
+    /**
+     * Compile a .zen page in memory
+     */
+    function compilePageInMemory(pagePath: string): CompiledPage | null {
+        try {
+            const layoutsDir = path.join(pagesDir, '../layouts')
+            const layouts = discoverLayouts(layoutsDir)
+
+            const source = fs.readFileSync(pagePath, 'utf-8')
+
+            // Find suitable layout
+            let processedSource = source
+            let layoutToUse = layouts.get('DefaultLayout')
+
+            if (layoutToUse) {
+                processedSource = processLayout(source, layoutToUse)
+            }
+
+            const result = compileZenSource(processedSource, pagePath)
+
+            if (!result.finalized) {
+                throw new Error('Compilation failed: No finalized output')
+            }
+
+            const routeDef = generateRouteDefinition(pagePath, pagesDir)
+
+            return {
+                html: result.finalized.html,
+                script: result.finalized.js,
+                styles: result.finalized.styles,
+                route: routeDef.path,
+                lastModified: Date.now()
+            }
+        } catch (error: any) {
+            logger.error(`Compilation error for ${pagePath}: ${error.message}`)
+            return null
+        }
+    }
+
+    /**
+     * Generate full HTML page from compiled output
+     */
+    function generateDevHTML(page: CompiledPage): string {
+        const runtimeTag = `<script src="/runtime.js"></script>`
+        const scriptTag = `<script>\n${page.script}\n</script>`
+        const allScripts = `${runtimeTag}\n${scriptTag}`
+
+        if (page.html.includes('</body>')) {
+            return page.html.replace('</body>', `${allScripts}\n</body>`)
+        }
+
+        return `${page.html}\n${allScripts}`
+    }
+
+    /**
+     * Find .zen page file for a given route
+     */
+    function findPageForRoute(route: string): string | null {
+        const exactPath = path.join(pagesDir, route === '/' ? 'index.zen' : `${route.slice(1)}.zen`)
+        if (fs.existsSync(exactPath)) return exactPath
+
+        const indexPath = path.join(pagesDir, route === '/' ? 'index.zen' : `${route.slice(1)}/index.zen`)
+        if (fs.existsSync(indexPath)) return indexPath
+
+        return null
+    }
+
+    const cachedRuntimeJS = generateRuntimeJS()
+
+    const server = serve({
+        port,
+        async fetch(req) {
+            const url = new URL(req.url)
+            const pathname = url.pathname
+            const ext = path.extname(pathname).toLowerCase()
+
+            if (pathname === '/runtime.js' || pathname === '/assets/bundle.js') {
+                return new Response(cachedRuntimeJS, {
+                    headers: {
+                        'Content-Type': 'application/javascript; charset=utf-8',
+                        'Cache-Control': 'no-cache'
+                    }
+                })
+            }
+
+            if (pathname === '/assets/styles.css' || pathname === '/styles/global.css' || pathname === '/app/styles/global.css') {
+                const globalCssPath = path.join(pagesDir, '../styles/global.css')
+                if (fs.existsSync(globalCssPath)) {
+                    const css = fs.readFileSync(globalCssPath, 'utf-8')
+                    return new Response(css, {
+                        headers: { 'Content-Type': 'text/css; charset=utf-8' }
+                    })
+                }
+            }
+
+            if (STATIC_EXTENSIONS.has(ext)) {
+                const publicPath = path.join(pagesDir, '../public', pathname)
+                const distPath = path.join(pagesDir, '../dist', pathname)
+                const appRelativePath = path.join(pagesDir, '..', pathname)
+
+                for (const filePath of [publicPath, distPath, appRelativePath]) {
+                    const file = Bun.file(filePath)
+                    if (await file.exists()) {
+                        return new Response(file)
+                    }
+                }
+                return new Response('Not found', { status: 404 })
+            }
+
+            const pagePath = findPageForRoute(pathname)
+            if (pagePath) {
+                let cached = pageCache.get(pagePath)
+                const stat = fs.statSync(pagePath)
+
+                if (!cached || stat.mtimeMs > cached.lastModified) {
+                    const compiled = compilePageInMemory(pagePath)
+                    if (compiled) {
+                        pageCache.set(pagePath, compiled)
+                        cached = compiled
+                    }
+                }
+
+                if (cached) {
+                    const html = generateDevHTML(cached)
+                    return new Response(html, {
+                        headers: { 'Content-Type': 'text/html; charset=utf-8' }
+                    })
+                }
+            }
+
+            return new Response('Not Found', { status: 404 })
+        }
+    })
+
+    logger.success(`Server running at http://localhost:${server.port}`)
+    logger.info('• In-memory compilation active')
+    logger.info('• Auto-recompile on file changes')
+    logger.info('Press Ctrl+C to stop')
+
+    await new Promise(() => { })
+}

package/cli/commands/index.ts

@@ -0,0 +1,112 @@
+/**
+ * @zenith/cli - Command Registry
+ * 
+ * Central registry for all CLI commands
+ */
+
+import { dev, type DevOptions } from './dev'
+import { preview, type PreviewOptions } from './preview'
+import { build, type BuildOptions } from './build'
+import { add, type AddOptions } from './add'
+import { remove } from './remove'
+import { create } from './create'
+import * as logger from '../utils/logger'
+
+export interface Command {
+    name: string
+    description: string
+    usage: string
+    run: (args: string[], options: Record<string, string>) => Promise<void>
+}
+
+export const commands: Command[] = [
+    {
+        name: 'create',
+        description: 'Create a new Zenith project',
+        usage: 'zenith create [project-name]',
+        async run(args) {
+            const projectName = args[0]
+            await create(projectName)
+        }
+    },
+    {
+        name: 'dev',
+        description: 'Start development server',
+        usage: 'zenith dev [--port <port>]',
+        async run(args, options) {
+            const opts: DevOptions = {}
+            if (options.port) opts.port = parseInt(options.port, 10)
+            await dev(opts)
+        }
+    },
+    {
+        name: 'preview',
+        description: 'Preview production build',
+        usage: 'zenith preview [--port <port>]',
+        async run(args, options) {
+            const opts: PreviewOptions = {}
+            if (options.port) opts.port = parseInt(options.port, 10)
+            await preview(opts)
+        }
+    },
+    {
+        name: 'build',
+        description: 'Build for production',
+        usage: 'zenith build [--outDir <dir>]',
+        async run(args, options) {
+            const opts: BuildOptions = {}
+            if (options.outDir) opts.outDir = options.outDir
+            await build(opts)
+        }
+    },
+    {
+        name: 'add',
+        description: 'Add a plugin',
+        usage: 'zenith add <plugin>',
+        async run(args) {
+            const pluginName = args[0]
+            if (!pluginName) {
+                logger.error('Plugin name required')
+                process.exit(1)
+            }
+            await add(pluginName)
+        }
+    },
+    {
+        name: 'remove',
+        description: 'Remove a plugin',
+        usage: 'zenith remove <plugin>',
+        async run(args) {
+            const pluginName = args[0]
+            if (!pluginName) {
+                logger.error('Plugin name required')
+                process.exit(1)
+            }
+            await remove(pluginName)
+        }
+    }
+]
+
+// Placeholder commands for future expansion
+export const placeholderCommands = ['test', 'export', 'deploy']
+
+export function getCommand(name: string): Command | undefined {
+    return commands.find(c => c.name === name)
+}
+
+export function showHelp(): void {
+    logger.header('Zenith CLI')
+    console.log('Usage: zenith <command> [options]\n')
+    console.log('Commands:')
+
+    for (const cmd of commands) {
+        console.log(`  ${cmd.name.padEnd(12)} ${cmd.description}`)
+    }
+
+    console.log('\nComing soon:')
+    for (const cmd of placeholderCommands) {
+        console.log(`  ${cmd.padEnd(12)} (not yet implemented)`)
+    }
+
+    console.log('\nRun `zenith <command> --help` for command-specific help.')
+}

package/cli/commands/preview.ts

@@ -0,0 +1,62 @@
+/**
+ * @zenith/cli - Preview Command
+ * 
+ * Serves the production build from the distribution directory.
+ */
+
+import path from 'path'
+import { serve } from 'bun'
+import { requireProject } from '../utils/project'
+import * as logger from '../utils/logger'
+
+export interface PreviewOptions {
+    port?: number
+}
+
+export async function preview(options: PreviewOptions = {}): Promise<void> {
+    const project = requireProject()
+    const distDir = project.distDir
+    const port = options.port || parseInt(process.env.PORT || '4173', 10)
+
+    logger.header('Zenith Preview Server')
+    logger.log(`Serving: ${distDir}`)
+
+    // File extensions that should be served as static assets
+    const STATIC_EXTENSIONS = new Set([
+        '.js', '.css', '.ico', '.png', '.jpg', '.jpeg', '.gif', '.svg',
+        '.webp', '.woff', '.woff2', '.ttf', '.eot', '.json', '.map'
+    ])
+
+    const server = serve({
+        port,
+        async fetch(req) {
+            const url = new URL(req.url)
+            const pathname = url.pathname
+            const ext = path.extname(pathname).toLowerCase()
+
+            if (STATIC_EXTENSIONS.has(ext)) {
+                const filePath = path.join(distDir, pathname)
+                const file = Bun.file(filePath)
+                if (await file.exists()) {
+                    return new Response(file)
+                }
+                return new Response('Not found', { status: 404 })
+            }
+
+            const indexPath = path.join(distDir, 'index.html')
+            const indexFile = Bun.file(indexPath)
+            if (await indexFile.exists()) {
+                return new Response(indexFile, {
+                    headers: { 'Content-Type': 'text/html; charset=utf-8' }
+                })
+            }
+
+            return new Response('No production build found. Run `zenith build` first.', { status: 500 })
+        }
+    })
+
+    logger.success(`Preview server running at http://localhost:${server.port}`)
+    logger.info('Press Ctrl+C to stop')
+
+    await new Promise(() => { })
+}

package/cli/commands/remove.ts

@@ -0,0 +1,33 @@
+/**
+ * @zenith/cli - Remove Command
+ * 
+ * Removes a plugin from the project registry
+ */
+
+import { requireProject } from '../utils/project'
+import { removePlugin, hasPlugin } from '../utils/plugin-manager'
+import * as logger from '../utils/logger'
+
+export async function remove(pluginName: string): Promise<void> {
+    requireProject()
+
+    logger.header('Remove Plugin')
+
+    if (!pluginName) {
+        logger.error('Plugin name required. Usage: zenith remove <plugin>')
+        process.exit(1)
+    }
+
+    if (!hasPlugin(pluginName)) {
+        logger.warn(`Plugin "${pluginName}" is not registered`)
+        return
+    }
+
+    const success = removePlugin(pluginName)
+
+    if (success) {
+        logger.info(`Plugin "${pluginName}" has been unregistered.`)
+        logger.info('Note: You may want to remove the package manually:')
+        logger.log(`  bun remove @zenith/plugin-${pluginName}`)
+    }
+}

package/cli/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @zenith/cli
+ * 
+ * CLI for Zenith framework - dev server, build tools, and plugin management
+ */
+
+export * from './commands/index'
+export * from './utils/logger'
+export * from './utils/project'
+export * from './utils/plugin-manager'

package/cli/main.ts

@@ -0,0 +1,101 @@
+/**
+ * @zenith/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/cli/utils/branding.ts

@@ -0,0 +1,153 @@
+/**
+ * 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('└─────────────────────────────────────────────────────────┘')}
+`)
+}