@zenithbuild/cli 0.4.11 → 1.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/cli",
-  "version": "0.4.11",
+  "version": "1.3.6",
   "description": "CLI for Zenith framework - dev server, build tools, and plugin management",
   "type": "module",
   "bin": {
@@ -50,14 +50,17 @@
   },
   "private": false,
   "peerDependencies": {
-    "@zenithbuild/core": "^1.2.15"
+    "@zenithbuild/core": "^1.3.0",
+    "@zenithbuild/compiler": "^1.3.0"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "@zenithbuild/compiler": "workspace:*"
   },
   "dependencies": {
-    "@zenithbuild/compiler": "^1.0.16",
-    "@zenithbuild/router": "^1.0.8",
+    "@zenithbuild/bundler": "workspace:*",
+    "@zenithbuild/router": "workspace:*",
+    "glob": "^13.0.0",
     "picocolors": "^1.0.0"
   }
-}
+}

package/src/commands/build.ts

@@ -6,7 +6,7 @@
 
 import { requireProject } from '../utils/project'
 import * as logger from '../utils/logger'
-import { buildSSG } from '@zenithbuild/compiler'
+import { buildSSG } from '../ssg-build.ts'
 
 export interface BuildOptions {
     outDir?: string

package/src/commands/dev.ts

@@ -25,23 +25,32 @@ import { requireProject } from '../utils/project'
 import * as logger from '../utils/logger'
 import * as brand from '../utils/branding'
 import {
-    compileZenSource,
-    discoverLayouts,
-    processLayout,
+    generateRuntime,
     generateBundleJS,
-    loadZenithConfig,
-    PluginRegistry,
-    createPluginContext,
-    getPluginDataByNamespace,
     compileCssAsync,
     resolveGlobalsCss,
+    bundlePageScript
+} from '@zenithbuild/bundler'
+import type { ZenManifest } from '@zenithbuild/bundler'
+import { generateRouteDefinition } from '@zenithbuild/router/manifest'
+import { compile } from '@zenithbuild/compiler'
+import { discoverLayouts } from '../discovery/layouts.ts'
+import { discoverComponents } from '../discovery/componentDiscovery.ts'
+import { processLayout } from '@zenithbuild/compiler/transform'
+import { loadZenithConfig } from '@zenithbuild/compiler/config'
+import {
+    PluginRegistry,
+    createPluginContext,
+    getPluginDataByNamespace
+} from '@zenithbuild/compiler/registry'
+import {
     createBridgeAPI,
     runPluginHooks,
     collectHookReturns,
     buildRuntimeEnvelope,
-    clearHooks,
-    type HookContext
-} from '@zenithbuild/compiler'
+    clearHooks
+} from '@zenithbuild/compiler/plugins'
+import type { HookContext } from '@zenithbuild/compiler/plugins'
 
 export interface DevOptions {
     port?: number
@@ -61,7 +70,7 @@ const pageCache = new Map<string, CompiledPage>()
  * Bundle page script using Rolldown to resolve npm imports at compile time.
  * Only called when compiler emits a BundlePlan - bundler performs no inference.
  */
-import { bundlePageScript, type BundlePlan, generateRouteDefinition } from '@zenithbuild/compiler'
+import type { BundlePlan } from '@zenithbuild/compiler'
 
 export async function dev(options: DevOptions = {}): Promise<void> {
     const project = requireProject()
@@ -153,88 +162,39 @@ export async function dev(options: DevOptions = {}): Promise<void> {
             const layoutsDir = path.join(pagesDir, '../layouts')
             const componentsDir = path.join(pagesDir, '../components')
             const layouts = discoverLayouts(layoutsDir)
-            const source = fs.readFileSync(pagePath, 'utf-8')
-
-            let processedSource = source
-            let layoutToUse = layouts.get('DefaultLayout')
-
-            if (layoutToUse) processedSource = processLayout(source, layoutToUse)
-
-            const result = await compileZenSource(processedSource, pagePath, {
-                componentsDir: fs.existsSync(componentsDir) ? componentsDir : undefined
-            })
-            if (!result.finalized) throw new Error('Compilation failed')
-
-            const routeDef = generateRouteDefinition(pagePath, pagesDir)
-
-
 
-            // Safely strip imports from the top of the script
-            // This relies on the fact that duplicate imports (from Rust codegen)
-            // appear at the beginning of result.finalized.js
-            let jsLines = result.finalized.js.split('\n')
-
-            // Remove lines from top that are imports, whitespace, or comments
-            while (jsLines.length > 0 && jsLines[0] !== undefined) {
-                const line = jsLines[0].trim()
-                if (
-                    line.startsWith('import ') ||
-                    line === '' ||
-                    line.startsWith('//') ||
-                    line.startsWith('/*') ||
-                    line.startsWith('*')
-                ) {
-                    jsLines.shift()
-                } else {
-                    break
+            // Manual component discovery since compiler is pure
+            const components = new Map<string, any>([...layouts])
+            if (fs.existsSync(componentsDir)) {
+                const discovered = discoverComponents(componentsDir)
+                for (const [k, v] of discovered) {
+                    components.set(k, v)
                 }
             }
 
-            let jsWithoutImports = jsLines.join('\n')
-
-            // PATCH: Fix unquoted keys with dashes (Rust codegen bug in jsx_lowerer)
-            // e.g. stroke-width: "1.5" -> "stroke-width": "1.5"
-            // We only apply this to the JS portions (Script and Expressions)
-            // to avoid corrupting the Styles section.
-            const stylesMarker = '// 6. Styles injection'
-            const parts = jsWithoutImports.split(stylesMarker)
-
-            if (parts.length > 1) {
-                // Apply patch only to the JS part
-                parts[0] = parts[0]!.replace(
-                    /(^|[{,])\s*([a-zA-Z][a-zA-Z0-9-]*-[a-zA-Z0-9-]*)\s*:/gm,
-                    '$1"$2":'
-                )
-                jsWithoutImports = parts.join(stylesMarker)
-            } else {
-                // Fallback if marker not found
-                jsWithoutImports = jsWithoutImports.replace(
-                    /(^|[{,])\s*([a-zA-Z][a-zA-Z0-9-]*-[a-zA-Z0-9-]*)\s*:/gm,
-                    '$1"$2":'
-                )
-            }
+            const source = fs.readFileSync(pagePath, 'utf-8')
 
-            // Combine: structured imports first, then cleaned script body
-            const fullScript = (result.finalized.npmImports || '') + '\n\n' + jsWithoutImports
+            const result = await compile(source, pagePath, {
+                components: components
+            })
+            if (!result.finalized || !result.finalized.manifest) throw new Error('Compilation failed')
 
 
+            const routeDef = generateRouteDefinition(pagePath, pagesDir)
 
-            // Bundle ONLY if compiler emitted a BundlePlan (no inference)
-            let bundledScript = fullScript
-            if (result.finalized.bundlePlan) {
-                // Compiler decided bundling is needed - pass plan with proper resolve roots
-                const plan: BundlePlan = {
-                    ...result.finalized.bundlePlan,
-                    entry: fullScript,
-                    resolveRoots: [path.join(rootDir, 'node_modules'), 'node_modules']
-                }
-                bundledScript = await bundlePageScript(plan)
+            // Use the new bundler to generate the runtime + author script
+            // This replaces all the manual regex patching and string concatenation
+            const manifest: ZenManifest = {
+                routes: [routeDef],
+                layouts: {}, // Dev server handles layouts dynamically
+                components: {}
             }
+            const { code } = generateRuntime(manifest, true)
 
             return {
                 html: result.finalized.html,
-                script: bundledScript,
-                styles: result.finalized.styles,
+                script: code,
+                styles: [], // Styles are now injected via the script
                 route: routeDef.path,
                 lastModified: Date.now()
             }
@@ -245,22 +205,15 @@ export async function dev(options: DevOptions = {}): Promise<void> {
     }
 
     /**
-     * Generate dev HTML with plugin data envelope
-     * 
-     * CLI collects payloads from plugins via 'cli:runtime:collect' hook.
-     * It serializes blindly - never inspecting what's inside.
+     * Generate dev HTML
      */
     async function generateDevHTML(page: CompiledPage): Promise<string> {
-        // Single neutral injection point
-        const runtimeTag = `<script src="/runtime.js"></script>`
         const scriptTag = `<script type="module">\n${page.script}\n</script>`
-        const allScripts = `${runtimeTag}\n${scriptTag}`
 
         let html = page.html.includes('</body>')
-            ? page.html.replace('</body>', `${allScripts}\n</body>`)
-            : `${page.html}\n${allScripts}`
+            ? page.html.replace('</body>', `${scriptTag}\n</body>`)
+            : `${page.html}\n${scriptTag}`
 
-        // Ensure DOCTYPE is present to prevent Quirks Mode (critical for SVG namespace)
         if (!html.trimStart().toLowerCase().startsWith('<!doctype')) {
             html = `<!DOCTYPE html>\n${html}`
         }

package/src/commands/index.ts

@@ -10,6 +10,7 @@ import { build, type BuildOptions } from './build'
 import { add, type AddOptions } from './add'
 import { remove } from './remove'
 import { create } from './create'
+import { lint, type LintOptions } from './lint'
 import * as logger from '../utils/logger'
 
 export interface Command {
@@ -84,6 +85,17 @@ export const commands: Command[] = [
             }
             await remove(pluginName)
         }
+    },
+    {
+        name: 'lint',
+        description: 'Audit project for Zenith Contract compliance',
+        usage: 'zenith lint [--fix]',
+        async run(args, options) {
+            const opts: LintOptions = {}
+            if (options.fix) opts.fix = true
+            if (options.incremental) opts.incremental = true
+            await lint(args, opts)
+        }
     }
 ]
 

package/src/commands/lint.ts

@@ -0,0 +1,140 @@
+/**
+ * @zenithbuild/cli - Lint Command
+ * 
+ * Scans for .zen files and enforces the Zenith Contract.
+ */
+
+import { glob } from 'glob'
+import { join } from 'path'
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs'
+import { compile } from '../../../zenith-compiler/dist/index.js'
+import * as logger from '../utils/logger'
+import picocolors from 'picocolors'
+import { createHash } from 'crypto'
+import { dirname } from 'path'
+
+export interface LintOptions {
+    fix?: boolean
+    incremental?: boolean
+}
+
+interface LintCache {
+    files: Record<string, string> // path -> hash
+}
+
+function findProjectRoot(startDir: string): string {
+    let current = startDir
+    while (current !== dirname(current)) {
+        if (existsSync(join(current, 'package.json')) || existsSync(join(current, '.zenith'))) {
+            return current
+        }
+        current = dirname(current)
+    }
+    return startDir
+}
+
+export async function lint(fileArgs: string[] = [], options: LintOptions = {}): Promise<void> {
+    logger.header('Zenith Safety Audit')
+
+    const isIncremental = options.incremental || false
+
+    // Find files
+    // Filter out flags that might have been passed in args
+    const filesToScan = fileArgs.filter(a => !a.startsWith('--'))
+    let files: string[] = []
+
+    if (filesToScan.length > 0) {
+        files = filesToScan
+    } else {
+        files = await glob('**/*.zen', {
+            ignore: ['**/node_modules/**', '**/dist/**', '.git/**', '**/test/**']
+        })
+    }
+
+    if (files.length === 0) {
+        logger.info('No .zen files found to audit.')
+        return
+    }
+
+    // Load lint cache - Optimized for monorepos
+    const root = findProjectRoot(process.cwd())
+    const cacheDir = join(root, '.zenith/cache')
+    const cachePath = join(cacheDir, 'lint-cache.json')
+    let lintCache: LintCache = { files: {} }
+
+    if (isIncremental && existsSync(cachePath)) {
+        try {
+            lintCache = JSON.parse(readFileSync(cachePath, 'utf-8'))
+        } catch (e) {
+            logger.warn('Failed to load lint cache, starting fresh.')
+        }
+    }
+
+    logger.info(`Auditing ${files.length} components${isIncremental ? ' (incremental)' : ''}...\n`)
+
+    let errorCount = 0
+    let fileCount = 0
+    let skippedCount = 0
+    const newCache: LintCache = { files: { ...lintCache.files } }
+
+    for (const file of files) {
+        fileCount++
+        const source = readFileSync(file, 'utf-8')
+        const hash = createHash('sha256').update(source).digest('hex')
+
+        if (isIncremental && lintCache.files[file] === hash) {
+            skippedCount++
+            continue
+        }
+
+        try {
+            // Run compilation with cache enabled for components
+            process.env.ZENITH_CACHE = '1'
+            await compile(source, file)
+            newCache.files[file] = hash
+        } catch (error: any) {
+            errorCount++
+            // Clear cache for this file on error
+            delete newCache.files[file]
+
+            if (error.name === 'InvariantError' || error.name === 'CompilerError') {
+                console.log(picocolors.red(picocolors.bold(`\n✖ ${file}:${error.line}:${error.column}`)))
+                console.log(picocolors.red(`  [${error.code || 'ERROR'}] ${error.message}`))
+
+                if (error.guarantee) {
+                    console.log(picocolors.yellow(`  Guarantee: ${error.guarantee}`))
+                }
+
+                if (error.context) {
+                    console.log(picocolors.dim(`  Context: ${error.context}`))
+                }
+
+                if (error.hints && error.hints.length > 0) {
+                    console.log(picocolors.cyan('  Hints:'))
+                    for (const hint of error.hints) {
+                        console.log(picocolors.cyan(`    - ${hint}`))
+                    }
+                }
+            } else {
+                console.log(picocolors.red(`\n✖ ${file}: Unexpected error`))
+                console.log(picocolors.red(`  ${error.message}`))
+            }
+        }
+    }
+
+    // Save updated cache
+    if (isIncremental) {
+        if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true })
+        writeFileSync(cachePath, JSON.stringify(newCache, null, 2))
+    }
+
+    console.log('')
+
+    if (errorCount > 0) {
+        logger.error(`Audit failed. Found ${errorCount} contract violations in ${fileCount} files.`)
+        process.exit(1)
+    } else {
+        const skipMsg = skippedCount > 0 ? ` (${skippedCount} unchanged files skipped)` : ''
+        logger.success(`Audit passed. ${fileCount} files checked${skipMsg}, 0 violations found.`)
+    }
+}

package/src/discovery/componentDiscovery.ts

@@ -0,0 +1,98 @@
+/**
+ * Component Discovery
+ * 
+ * Discovers and catalogs components in a Zenith project using standard 
+ * file system walking and the unified native "syscall" for metadata.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import { parseZenFile, type TemplateNode, type ExpressionIR } from '@zenithbuild/compiler'
+
+export interface SlotDefinition {
+    name: string | null  // null = default slot, string = named slot
+    location: {
+        line: number
+        column: number
+    }
+}
+
+export interface ComponentMetadata {
+    name: string          // Component name (e.g., "Card", "Button")
+    path: string          // Absolute path to .zen file
+    template: string      // Raw template HTML
+    nodes: TemplateNode[] // Parsed template nodes
+    expressions: ExpressionIR[] // Component-level expressions
+    slots: SlotDefinition[]
+    props: string[]       // Declared props
+    states: Record<string, string> // Declared state (name -> initializer)
+    styles: string[]      // Raw CSS from <style> blocks
+    script: string | null         // Raw script content for bundling
+    scriptAttributes: Record<string, string> | null  // Script attributes (setup, lang)
+    hasScript: boolean
+    hasStyles: boolean
+}
+
+/**
+ * Discover all components in a directory recursively
+ */
+export function discoverComponents(baseDir: string): Map<string, ComponentMetadata> {
+    const components = new Map<string, ComponentMetadata>()
+
+    if (!fs.existsSync(baseDir)) return components;
+
+    const walk = (dir: string) => {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const fullPath = path.join(dir, file);
+            if (fs.statSync(fullPath).isDirectory()) {
+                walk(fullPath);
+            } else if (file.endsWith('.zen')) {
+                const name = path.basename(file, '.zen');
+                try {
+                    // Call the "One True Bridge" in metadata mode
+                    const ir = parseZenFile(fullPath, undefined, { mode: 'metadata' });
+
+                    // Map IR to ComponentMetadata format
+                    components.set(name, {
+                        name,
+                        path: fullPath,
+                        template: ir.template.raw,
+                        nodes: ir.template.nodes,
+                        expressions: ir.template.expressions,
+                        slots: [], // Native bridge needs to return slot info in IR if used
+                        props: ir.props || [],
+                        states: ir.script?.states || {},
+                        styles: ir.styles?.map((s: any) => s.raw) || [],
+                        script: ir.script?.raw || null,
+                        scriptAttributes: ir.script?.attributes || null,
+                        hasScript: !!ir.script,
+                        hasStyles: ir.styles?.length > 0
+                    });
+                } catch (e) {
+                    console.error(`[Zenith Discovery] Failed to parse component ${file}:`, e);
+                }
+            }
+        }
+    };
+
+    walk(baseDir);
+    return components;
+}
+
+/**
+ * Universal Zenith Component Tag Rule: PascalCase
+ */
+export function isComponentTag(tagName: string): boolean {
+    return tagName.length > 0 && tagName[0] === tagName[0]?.toUpperCase()
+}
+
+/**
+ * Get component metadata by name
+ */
+export function getComponent(
+    components: Map<string, ComponentMetadata>,
+    name: string
+): ComponentMetadata | undefined {
+    return components.get(name)
+}

package/src/discovery/layouts.ts

@@ -0,0 +1,50 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { parseZenFile } from '@zenithbuild/compiler'
+
+export interface LayoutMetadata {
+    name: string
+    filePath: string
+    props: string[]
+    states: Map<string, any>
+    html: string
+    scripts: string[]
+    styles: string[]
+}
+
+/**
+ * Discover layouts in a directory using standard file system walking
+ * and the unified native bridge for metadata.
+ */
+export function discoverLayouts(layoutsDir: string): Map<string, LayoutMetadata> {
+    const layouts = new Map<string, LayoutMetadata>()
+
+    if (!fs.existsSync(layoutsDir)) return layouts
+
+    const files = fs.readdirSync(layoutsDir)
+    for (const file of files) {
+        if (file.endsWith('.zen')) {
+            const fullPath = path.join(layoutsDir, file)
+            const name = path.basename(file, '.zen')
+
+            try {
+                // Call the "One True Bridge" in metadata mode
+                const ir = parseZenFile(fullPath, undefined, { mode: 'metadata' })
+
+                layouts.set(name, {
+                    name,
+                    filePath: fullPath,
+                    props: ir.props || [],
+                    states: new Map(),
+                    html: ir.template.raw,
+                    scripts: ir.script ? [ir.script.content] : [],
+                    styles: ir.styles?.map((s: any) => s.raw) || []
+                })
+            } catch (e) {
+                console.error(`[Zenith Layout Discovery] Failed to parse layout ${file}:`, e)
+            }
+        }
+    }
+
+    return layouts
+}

package/src/serve.ts

@@ -0,0 +1,92 @@
+/**
+ * Zenith Development Server
+ * 
+ * SPA-compatible server that:
+ * - Serves static assets directly (js, css, ico, images)
+ * - Serves index.html for all other routes (SPA fallback)
+ * 
+ * This enables client-side routing to work on:
+ * - Direct URL entry
+ * - Hard refresh
+ * - Back/forward navigation
+ */
+
+import { serve } from "bun"
+import path from "path"
+
+const distDir = path.resolve(process.cwd(), "dist")
+
+// 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"
+])
+
+serve({
+    port: 3000,
+
+    async fetch(req) {
+        const url = new URL(req.url)
+        const pathname = url.pathname
+
+        // Get file extension
+        const ext = path.extname(pathname).toLowerCase()
+
+        // Check if this is a static asset request
+        if (STATIC_EXTENSIONS.has(ext)) {
+            const filePath = path.join(distDir, pathname)
+            const file = Bun.file(filePath)
+
+            // Check if file exists
+            if (await file.exists()) {
+                return new Response(file)
+            }
+
+            // Static file not found
+            return new Response("Not found", { status: 404 })
+        }
+
+        // For all other routes, serve index.html (SPA fallback)
+        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"
+                }
+            })
+        }
+
+        // No index.html found - likely need to run build first
+        return new Response(
+            `<html>
+        <head><title>Zenith - Build Required</title></head>
+        <body style="font-family: system-ui; padding: 2rem; text-align: center;">
+          <h1>Build Required</h1>
+          <p>Run <code>zenith build</code> first to compile the pages.</p>
+        </body>
+      </html>`,
+            {
+                status: 500,
+                headers: { "Content-Type": "text/html; charset=utf-8" }
+            }
+        )
+    }
+})
+
+console.log("🚀 Zenith dev server running at http://localhost:3000")
+console.log("   SPA mode: All routes serve index.html")