@zenithbuild/cli 0.4.10 → 1.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/cli",
-  "version": "0.4.10",
+  "version": "1.3.4",
   "description": "CLI for Zenith framework - dev server, build tools, and plugin management",
   "type": "module",
   "bin": {
@@ -50,14 +50,16 @@
   },
   "private": false,
   "peerDependencies": {
-    "@zenithbuild/core": "^1.2.14"
+    "@zenithbuild/core": "^1.3.0"
   },
   "devDependencies": {
     "@types/bun": "latest"
   },
   "dependencies": {
-    "@zenithbuild/compiler": "^1.0.15",
-    "@zenithbuild/router": "^1.0.7",
+    "@zenithbuild/compiler": "1.3.6",
+    "@zenithbuild/bundler": "1.3.4",
+    "@zenithbuild/router": "1.3.0",
+    "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 '../../../zenith-compiler/dist/index.js'
 
 export interface BuildOptions {
     outDir?: string

package/src/commands/dev.ts

@@ -24,24 +24,26 @@ import { serve, type ServerWebSocket } from 'bun'
 import { requireProject } from '../utils/project'
 import * as logger from '../utils/logger'
 import * as brand from '../utils/branding'
+import { generateRuntime, type ZenManifest } from '@zenithbuild/bundler'
+import { compile } from '@zenithbuild/compiler'
+import { discoverLayouts } from '@zenithbuild/compiler/layouts'
+import { processLayout } from '@zenithbuild/compiler/transform'
+import { generateBundleJS } from '@zenithbuild/compiler/runtime'
+import { loadZenithConfig } from '@zenithbuild/compiler/config'
 import {
-    compileZenSource,
-    discoverLayouts,
-    processLayout,
-    generateBundleJS,
-    loadZenithConfig,
     PluginRegistry,
     createPluginContext,
-    getPluginDataByNamespace,
-    compileCssAsync,
-    resolveGlobalsCss,
+    getPluginDataByNamespace
+} from '@zenithbuild/compiler/registry'
+import { compileCssAsync, resolveGlobalsCss } from '@zenithbuild/compiler/css'
+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 +63,9 @@ 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 { bundlePageScript } from '@zenithbuild/compiler/bundler'
+import { generateRouteDefinition } from '@zenithbuild/compiler/bundler'
+import type { BundlePlan } from '@zenithbuild/compiler'
 
 export async function dev(options: DevOptions = {}): Promise<void> {
     const project = requireProject()
@@ -155,86 +159,23 @@ export async function dev(options: DevOptions = {}): Promise<void> {
             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
+            const result = await compile(source, pagePath, {
+                componentsDir: fs.existsSync(componentsDir) ? componentsDir : undefined,
+                components: layouts
             })
-            if (!result.finalized) throw new Error('Compilation failed')
+            if (!result.finalized || !result.finalized.manifest) 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
-                }
-            }
-
-            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":'
-                )
-            }
-
-            // Combine: structured imports first, then cleaned script body
-            const fullScript = (result.finalized.npmImports || '') + '\n\n' + jsWithoutImports
-
-
-
-            // 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 = result.finalized.manifest
+            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 +186,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.`)
+    }
+}