@zenithbuild/core 0.1.0 → 0.3.1

package/cli/utils/logger.ts

@@ -0,0 +1,40 @@
+/**
+ * @zenith/cli - Logger Utility
+ * 
+ * Colored console output for CLI feedback
+ */
+
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m'
+}
+
+export function log(message: string): void {
+    console.log(`${colors.cyan}[zenith]${colors.reset} ${message}`)
+}
+
+export function success(message: string): void {
+    console.log(`${colors.green}✓${colors.reset} ${message}`)
+}
+
+export function warn(message: string): void {
+    console.log(`${colors.yellow}⚠${colors.reset} ${message}`)
+}
+
+export function error(message: string): void {
+    console.error(`${colors.red}✗${colors.reset} ${message}`)
+}
+
+export function info(message: string): void {
+    console.log(`${colors.blue}ℹ${colors.reset} ${message}`)
+}
+
+export function header(title: string): void {
+    console.log(`\n${colors.bright}${colors.cyan}${title}${colors.reset}\n`)
+}

package/cli/utils/plugin-manager.ts

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

@@ -0,0 +1,71 @@
+/**
+ * @zenith/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 @zenith/* dependency
+                const hasZenith = Object.keys(deps).some(d => d.startsWith('@zenith/'))
+                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
+
+    return {
+        root,
+        pagesDir: path.join(root, 'app/pages'),
+        distDir: path.join(root, 'app/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 @zenith/* dependencies.')
+    }
+    return project
+}

package/compiler/build-analyzer.ts

@@ -0,0 +1,122 @@
+/**
+ * Zenith Build Analyzer
+ * 
+ * Analyzes .zen page source to determine build strategy:
+ * - Static: Pure HTML+CSS, no JS needed
+ * - Hydration: Has state/events/hooks, needs page-specific JS
+ * - SSR: Uses useFetchServer, needs server rendering
+ * - SPA: Uses ZenLink with passHref, needs client router
+ */
+
+export interface PageAnalysis {
+    /** Page has state declarations that need hydration */
+    hasState: boolean
+    /** Page has event handlers (onclick, etc.) */
+    hasEventHandlers: boolean
+    /** Page uses lifecycle hooks (zenOnMount, zenOnUnmount) */
+    hasLifecycleHooks: boolean
+    /** Page uses useFetchServer (requires SSR) */
+    usesServerFetch: boolean
+    /** Page uses useFetchClient (client-side data) */
+    usesClientFetch: boolean
+    /** Page uses ZenLink with passHref (SPA navigation) */
+    usesZenLink: boolean
+    /** Page uses reactive expressions in templates */
+    hasReactiveExpressions: boolean
+
+    /** Computed: page needs any JavaScript */
+    needsHydration: boolean
+    /** Computed: page is purely static (no JS) */
+    isStatic: boolean
+    /** Computed: page needs SSR */
+    needsSSR: boolean
+}
+
+/**
+ * Analyze a .zen page source to determine build requirements
+ */
+export function analyzePageSource(source: string): PageAnalysis {
+    // Extract script content for analysis
+    const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/i)
+    const scriptContent = scriptMatch?.[1] || ''
+
+    // Extract template content (everything outside script/style)
+    const templateContent = source
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+
+    // Check for state declarations: "state varName = ..."
+    const hasState = /\bstate\s+\w+\s*=/.test(scriptContent)
+
+    // Check for event handlers in template
+    const hasEventHandlers = /\bon(click|change|input|submit|focus|blur|keydown|keyup|keypress|mousedown|mouseup|mouseover|mouseout|mouseenter|mouseleave)\s*=\s*["'{]/.test(templateContent)
+
+    // Check for lifecycle hooks
+    const hasLifecycleHooks = /\bzen(OnMount|OnUnmount)\s*\(/.test(scriptContent)
+
+    // Check for server fetch
+    const usesServerFetch = /\buseFetchServer\s*\(/.test(scriptContent)
+
+    // Check for client fetch
+    const usesClientFetch = /\buseFetchClient\s*\(/.test(scriptContent)
+
+    // Check for ZenLink with passHref
+    const usesZenLink = /<ZenLink[^>]*passHref[^>]*>/.test(templateContent)
+
+    // Check for reactive expressions in template: {expression}
+    // Must be actual expressions, not just static text
+    // Exclude attribute values like href="/path"
+    const hasReactiveExpressions = /{[a-zA-Z_][a-zA-Z0-9_]*}/.test(templateContent)
+
+    // Compute derived properties
+    const needsHydration = hasState || hasEventHandlers || hasLifecycleHooks ||
+        usesClientFetch || hasReactiveExpressions
+    const isStatic = !needsHydration && !usesServerFetch
+    const needsSSR = usesServerFetch
+
+    return {
+        hasState,
+        hasEventHandlers,
+        hasLifecycleHooks,
+        usesServerFetch,
+        usesClientFetch,
+        usesZenLink,
+        hasReactiveExpressions,
+        needsHydration,
+        isStatic,
+        needsSSR
+    }
+}
+
+/**
+ * Get a human-readable summary of the page analysis
+ */
+export function getAnalysisSummary(analysis: PageAnalysis): string {
+    const flags: string[] = []
+
+    if (analysis.isStatic) {
+        flags.push('STATIC (no JS)')
+    } else {
+        if (analysis.hasState) flags.push('state')
+        if (analysis.hasEventHandlers) flags.push('events')
+        if (analysis.hasLifecycleHooks) flags.push('lifecycle')
+        if (analysis.hasReactiveExpressions) flags.push('reactive')
+        if (analysis.usesClientFetch) flags.push('clientFetch')
+    }
+
+    if (analysis.needsSSR) flags.push('SSR')
+    if (analysis.usesZenLink) flags.push('SPA')
+
+    return flags.length > 0 ? flags.join(', ') : 'minimal'
+}
+
+/**
+ * Determine build output type for a page
+ */
+export type BuildOutputType = 'static' | 'hydrated' | 'ssr'
+
+export function getBuildOutputType(analysis: PageAnalysis): BuildOutputType {
+    if (analysis.needsSSR) return 'ssr'
+    if (analysis.needsHydration) return 'hydrated'
+    return 'static'
+}

package/compiler/discovery/layouts.ts

@@ -0,0 +1,61 @@
+import fs from 'fs'
+import path from 'path'
+import { parseTemplate } from '../parse/parseTemplate'
+import { parseScript } from '../parse/parseScript'
+import { extractProps, extractStateDeclarations } from '../parse/scriptAnalysis'
+
+export interface LayoutMetadata {
+    name: string
+    filePath: string
+    props: string[]
+    states: Map<string, string>
+    html: string
+    scripts: string[]
+    styles: string[]
+}
+
+/**
+ * Discover layouts in a directory
+ */
+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 filePath = path.join(layoutsDir, file)
+            const name = path.basename(file, '.zen')
+            const source = fs.readFileSync(filePath, 'utf-8')
+
+            const script = parseScript(source)
+            const props = script ? extractProps(script.raw) : []
+            const states = script ? extractStateDeclarations(script.raw) : new Map()
+
+            // Extract styles
+            const styles: string[] = []
+            const styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi
+            let match
+            while ((match = styleRegex.exec(source)) !== null) {
+                if (match[1]) styles.push(match[1].trim())
+            }
+
+            // Extract HTML (everything except script/style)
+            let html = source.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+            html = html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '').trim()
+
+            layouts.set(name, {
+                name,
+                filePath,
+                props,
+                states,
+                html,
+                scripts: script ? [script.raw] : [],
+                styles
+            })
+        }
+    }
+
+    return layouts
+}

package/compiler/index.ts

@@ -1,44 +1,60 @@
-/**
- * Zenith Compiler
- * 
- * Phase 1: Parse & Extract
- * Phase 2: Transform IR → Static HTML + Runtime Bindings
- * Phase 8/9/10: Finalize Output with Validation
- * 
- * This compiler observes .zen files, extracts their structure,
- * transforms them into static HTML with explicit bindings,
- * and validates/finalizes output for browser execution.
- */
-
-import { parseZenFile } from './parse/parseZenFile'
+import { readFileSync } from 'fs'
+import { parseTemplate } from './parse/parseTemplate'
+import { parseScript } from './parse/parseScript'
 import { transformTemplate } from './transform/transformTemplate'
 import { finalizeOutputOrThrow } from './finalize/finalizeOutput'
-import type { ZenIR } from './ir/types'
+import type { ZenIR, StyleIR } from './ir/types'
 import type { CompiledTemplate } from './output/types'
 import type { FinalizedOutput } from './finalize/finalizeOutput'
 
 /**
  * Compile a .zen file into IR and CompiledTemplate
- * 
- * Phase 1: Parses and extracts structure
- * Phase 2: Transforms IR into static HTML with bindings
- * Phase 8/9/10: Validates and finalizes output
  */
-export function compileZen(filePath: string): { 
+export function compileZen(filePath: string): {
   ir: ZenIR
   compiled: CompiledTemplate
   finalized?: FinalizedOutput
 } {
-  const ir = parseZenFile(filePath)
+  const source = readFileSync(filePath, 'utf-8')
+  return compileZenSource(source, filePath)
+}
+
+/**
+ * Compile Zen source string into IR and CompiledTemplate
+ */
+export function compileZenSource(source: string, filePath: string): {
+  ir: ZenIR
+  compiled: CompiledTemplate
+  finalized?: FinalizedOutput
+} {
+  // Parse template
+  const template = parseTemplate(source, filePath)
+
+  // Parse script
+  const script = parseScript(source)
+
+  // Parse styles
+  const styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi
+  const styles: StyleIR[] = []
+  let match
+  while ((match = styleRegex.exec(source)) !== null) {
+    if (match[1]) styles.push({ raw: match[1].trim() })
+  }
+
+  const ir: ZenIR = {
+    filePath,
+    template,
+    script,
+    styles
+  }
+
   const compiled = transformTemplate(ir)
-  
-  // Phase 8/9/10: Finalize output with validation
-  // This ensures build fails on invalid expressions
+
   try {
     const finalized = finalizeOutputOrThrow(ir, compiled)
     return { ir, compiled, finalized }
   } catch (error: any) {
-    // Re-throw with context
     throw new Error(`Failed to finalize output for ${filePath}:\n${error.message}`)
   }
 }
+

package/compiler/ir/types.ts

@@ -70,6 +70,7 @@ export type ExpressionIR = {
 
 export type ScriptIR = {
   raw: string
+  attributes: Record<string, string>
 }
 
 export type StyleIR = {

package/compiler/parse/parseScript.ts

@@ -8,15 +8,39 @@
 import type { ScriptIR } from '../ir/types'
 
 export function parseScript(html: string): ScriptIR | null {
-  // Extract script content using regex (simple extraction for Phase 1)
-  const scriptMatch = html.match(/<script[^>]*>([\s\S]*?)<\/script>/i)
-  
-  if (!scriptMatch || !scriptMatch[1]) {
+  const scripts: string[] = []
+  const attributes: Record<string, string> = {}
+
+  const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi
+  let match
+
+  while ((match = scriptRegex.exec(html)) !== null) {
+    const attrString = match[1] || ''
+    const content = match[2] || ''
+
+    // Parse attributes
+    const attrRegex = /([a-z0-9-]+)(?:=(?:"([^"]*)"|'([^']*)'|([^>\s]+)))?/gi
+    let attrMatch
+    while ((attrMatch = attrRegex.exec(attrString)) !== null) {
+      const name = attrMatch[1]
+      if (name) {
+        const value = attrMatch[2] || attrMatch[3] || attrMatch[4] || 'true'
+        attributes[name] = value
+      }
+    }
+
+    if (content) {
+      scripts.push(content.trim())
+    }
+  }
+
+  if (scripts.length === 0) {
     return null
   }
 
   return {
-    raw: scriptMatch[1].trim()
+    raw: scripts.join('\n\n'),
+    attributes
   }
 }