@zenithbuild/core 1.2.2 → 1.2.4

package/compiler/validate/validateExpressions.ts

@@ -1,168 +0,0 @@
-/**
- * Expression Validation
- * 
- * Phase 8/9/10: Compile-time validation of all expressions
- * 
- * Ensures all expressions are valid JavaScript and will not cause runtime errors.
- * Build fails immediately if any expression is invalid.
- */
-
-import type { ExpressionIR } from '../ir/types'
-import { CompilerError } from '../errors/compilerError'
-
-/**
- * Validation result
- */
-export interface ValidationResult {
-  valid: boolean
-  errors: CompilerError[]
-}
-
-/**
- * Validate all expressions in the IR
- * 
- * @param expressions - Array of expressions to validate
- * @param filePath - Source file path for error reporting
- * @returns Validation result with errors
- */
-export function validateExpressions(
-  expressions: ExpressionIR[],
-  filePath: string
-): ValidationResult {
-  const errors: CompilerError[] = []
-
-  for (const expr of expressions) {
-    const exprErrors = validateSingleExpression(expr, filePath)
-    errors.push(...exprErrors)
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors
-  }
-}
-
-/**
- * Validate a single expression
- */
-function validateSingleExpression(
-  expr: ExpressionIR,
-  filePath: string
-): CompilerError[] {
-  const errors: CompilerError[] = []
-  const { id, code, location } = expr
-
-  // Basic syntax validation using a safe approach
-  // We don't execute the code, just validate syntax
-  // Note: Expressions may contain JSX/HTML syntax (e.g., condition && <element>)
-  // which is not valid JavaScript but is valid in our expression language.
-  // We skip strict JavaScript validation for expressions that contain JSX.
-  
-  const hasJSX = /<[a-zA-Z]/.test(code) || /\/>/.test(code)
-  
-  if (!hasJSX) {
-    // Only validate JavaScript syntax if there's no JSX
-    // Note: Using Function constructor here is for syntax validation only (compile-time)
-    // This is safe because:
-    // 1. It's only called at compile time, not runtime
-    // 2. We're only checking syntax, not executing the code
-    // 3. The actual runtime uses pre-compiled functions, not Function constructor
-    try {
-      // Use Function constructor to validate syntax (doesn't execute)
-      // This is compile-time only - runtime never uses Function constructor
-      new Function('state', 'loaderData', 'props', 'stores', `return ${code}`)
-    } catch (error: any) {
-      errors.push(
-        new CompilerError(
-          `Invalid expression syntax: ${code}\n${error.message}`,
-          filePath,
-          location.line,
-          location.column
-        )
-      )
-    }
-  }
-  // If hasJSX, we skip JavaScript validation - JSX syntax is handled by the parser/runtime
-
-  // Check for dangerous patterns
-  if (code.includes('eval(') || code.includes('Function(') || code.includes('with (')) {
-    errors.push(
-      new CompilerError(
-        `Expression contains unsafe code: ${code}`,
-        filePath,
-        location.line,
-        location.column
-      )
-    )
-  }
-
-  // Check for undefined global references (basic heuristic)
-  // This is a simple check - can be enhanced with AST parsing
-  const globalPattern = /\b(window|document|console|globalThis)\./g
-  const matches = code.match(globalPattern)
-  if (matches && matches.length > 0) {
-    // Warn but don't fail - some global access might be intentional
-    // In a stricter mode, we could fail here
-  }
-
-  // Check for common syntax errors
-  const openBraces = (code.match(/\{/g) || []).length
-  const closeBraces = (code.match(/\}/g) || []).length
-  const openParens = (code.match(/\(/g) || []).length
-  const closeParens = (code.match(/\)/g) || []).length
-  const openBrackets = (code.match(/\[/g) || []).length
-  const closeBrackets = (code.match(/\]/g) || []).length
-
-  if (openBraces !== closeBraces) {
-    errors.push(
-      new CompilerError(
-        `Mismatched braces in expression: ${code}`,
-        filePath,
-        location.line,
-        location.column
-      )
-    )
-  }
-
-  if (openParens !== closeParens) {
-    errors.push(
-      new CompilerError(
-        `Mismatched parentheses in expression: ${code}`,
-        filePath,
-        location.line,
-        location.column
-      )
-    )
-  }
-
-  if (openBrackets !== closeBrackets) {
-    errors.push(
-      new CompilerError(
-        `Mismatched brackets in expression: ${code}`,
-        filePath,
-        location.line,
-        location.column
-      )
-    )
-  }
-
-  return errors
-}
-
-/**
- * Validate and throw if invalid
- * 
- * @throws CompilerError if any expression is invalid
- */
-export function validateExpressionsOrThrow(
-  expressions: ExpressionIR[],
-  filePath: string
-): void {
-  const result = validateExpressions(expressions, filePath)
-  
-  if (!result.valid && result.errors.length > 0) {
-    // Throw the first error (can be enhanced to collect all)
-    throw result.errors[0]
-  }
-}
-

package/core/config/index.ts

@@ -1,18 +0,0 @@
-/**
- * Zenith Config
- * 
- * Public exports for zenith/config
- * 
- * Core exports ONLY generic plugin infrastructure.
- * Plugin-specific types are owned by their respective plugins.
- */
-
-export { defineConfig } from './types';
-export type {
-    ZenithConfig,
-    ZenithPlugin,
-    PluginContext,
-    PluginData
-} from './types';
-export { loadZenithConfig, hasZenithConfig } from './loader';
-

package/core/config/loader.ts

@@ -1,69 +0,0 @@
-/**
- * Zenith Config Loader
- * 
- * Loads zenith.config.ts from the project root
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import type { ZenithConfig } from './types';
-
-/**
- * Load zenith.config.ts from the project root
- * 
- * @param projectRoot - Absolute path to the project root
- * @returns Parsed ZenithConfig or empty config if not found
- */
-export async function loadZenithConfig(projectRoot: string): Promise<ZenithConfig> {
-    // Check for TypeScript config first, then JavaScript
-    const configPaths = [
-        path.join(projectRoot, 'zenith.config.ts'),
-        path.join(projectRoot, 'zenith.config.js'),
-        path.join(projectRoot, 'zenith.config.mjs'),
-    ];
-
-    let configPath: string | null = null;
-    for (const p of configPaths) {
-        if (fs.existsSync(p)) {
-            configPath = p;
-            break;
-        }
-    }
-
-    if (!configPath) {
-        // No config file found, return empty config
-        return { plugins: [] };
-    }
-
-    try {
-        // Use dynamic import to load the config
-        // Bun supports importing TS files directly
-        const configModule = await import(configPath);
-        const config = configModule.default || configModule;
-
-        // Validate basic structure
-        if (typeof config !== 'object' || config === null) {
-            console.warn(`[Zenith] Invalid config format in ${configPath}`);
-            return { plugins: [] };
-        }
-
-        return config as ZenithConfig;
-    } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`[Zenith] Failed to load config from ${configPath}:`, message);
-        return { plugins: [] };
-    }
-}
-
-/**
- * Check if a zenith.config.ts exists in the project
- */
-export function hasZenithConfig(projectRoot: string): boolean {
-    const configPaths = [
-        path.join(projectRoot, 'zenith.config.ts'),
-        path.join(projectRoot, 'zenith.config.js'),
-        path.join(projectRoot, 'zenith.config.mjs'),
-    ];
-
-    return configPaths.some(p => fs.existsSync(p));
-}

package/core/config/types.ts

@@ -1,119 +0,0 @@
-/**
- * Zenith Config Types
- * 
- * Configuration interfaces for zenith.config.ts
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * HOOK OWNERSHIP RULE (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * Core may ONLY define types that are universally valid in all Zenith applications.
- * Plugin-specific types MUST be owned by their respective plugins.
- * 
- * ✅ ALLOWED in Core:
- *    - ZenithConfig, ZenithPlugin, PluginContext (generic plugin infrastructure)
- *    - Universal lifecycle hooks (onMount, onUnmount)
- *    - Reactivity primitives (signal, effect, etc.)
- * 
- * ❌ PROHIBITED in Core:
- *    - Content plugin types (ContentItem, ContentSourceConfig, etc.)
- *    - Router plugin types (RouteState, NavigationGuard, etc.)
- *    - Documentation plugin types
- *    - Any type that exists only because a plugin exists
- * 
- * If removing a plugin would make a type meaningless, that type belongs to the plugin.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-
-import type { CLIBridgeAPI } from '../plugins/bridge';
-
-// ============================================
-// Core Plugin Types (Generic Infrastructure)
-// ============================================
-
-/**
- * Generic data record for plugin data exchange
- * Plugins define their own specific types internally
- */
-export type PluginData = Record<string, unknown[]>;
-
-/**
- * Context passed to plugins during setup
- * 
- * This is intentionally generic - plugins define their own data shapes.
- * Core provides the stage, plugins bring the actors.
- */
-export interface PluginContext {
-    /** Absolute path to project root */
-    projectRoot: string;
-
-    /** 
-     * Set plugin data for the runtime
-     * 
-     * Generic setter - plugins define their own data structures.
-     * The runtime stores this data and makes it available to components.
-     * 
-     * @example
-     * // Content plugin uses it for content items
-     * ctx.setPluginData('content', contentItems);
-     * 
-     * // Analytics plugin uses it for tracking config
-     * ctx.setPluginData('analytics', analyticsConfig);
-     */
-    setPluginData: (namespace: string, data: unknown[]) => void;
-
-    /** Additional options passed from config */
-    options?: Record<string, unknown>;
-}
-
-/**
- * A Zenith plugin definition
- * 
- * Plugins are self-contained, removable extensions.
- * Core must build and run identically with or without any plugin installed.
- */
-export interface ZenithPlugin {
-    /** Unique plugin name */
-    name: string;
-
-    /** Setup function called during initialization */
-    setup: (ctx: PluginContext) => void | Promise<void>;
-
-    /** Plugin-specific configuration (preserved for reference) */
-    config?: unknown;
-
-    /**
-     * Optional CLI registration
-     * 
-     * Plugin receives the CLI bridge API to register namespaced hooks.
-     * CLI lifecycle hooks: 'cli:*' (owned by CLI)
-     * Plugin hooks: '<namespace>:*' (owned by plugin)
-     * 
-     * @example
-     * registerCLI(api) {
-     *   api.on('cli:runtime:collect', (ctx) => {
-     *     return { namespace: 'myPlugin', payload: ctx.getPluginData('myPlugin') }
-     *   })
-     * }
-     */
-    registerCLI?: (api: CLIBridgeAPI) => void;
-}
-
-// ============================================
-// Main Config Types
-// ============================================
-
-/**
- * Zenith configuration object
- */
-export interface ZenithConfig {
-    /** List of plugins to load */
-    plugins?: ZenithPlugin[];
-}
-
-/**
- * Define a Zenith configuration with full type safety
- */
-export function defineConfig(config: ZenithConfig): ZenithConfig {
-    return config;
-}

package/core/plugins/bridge.ts

@@ -1,193 +0,0 @@
-/**
- * Zenith CLI Bridge
- * 
- * The ONLY interface between CLI and plugins.
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * CLI BRIDGE RULES (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * 1. No runtime emitters - plugins return data, CLI serializes blindly
- * 2. No plugin typing - all data is unknown
- * 3. No semantic helpers - CLI is blind to what data means
- * 
- * The CLI dispatches hooks and collects returns. It never inspects payloads.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-
-/**
- * CLI Bridge API - passed to plugins during CLI registration
- * 
- * Plugins use this to register namespaced hooks.
- * CLI lifecycle hooks: 'cli:*'
- * Plugin hooks: '<namespace>:*'
- */
-export interface CLIBridgeAPI {
-    /**
-     * Register a hook handler
-     * 
-     * @param hook - Namespaced hook name (e.g., 'cli:runtime:collect', 'content:dev:watch')
-     * @param handler - Handler function that receives context and optionally returns data
-     */
-    on(hook: string, handler: (ctx: HookContext) => unknown | void | Promise<unknown | void>): void
-}
-
-/**
- * Context passed to hook handlers
- * 
- * CLI provides this but never uses getPluginData itself.
- * Only plugins call getPluginData with their own namespace.
- */
-export interface HookContext {
-    /** Absolute path to project root */
-    projectRoot: string
-
-    /**
-     * Opaque data accessor
-     * 
-     * CLI passes this function but NEVER calls it.
-     * Only plugins use it to access their own namespaced data.
-     */
-    getPluginData: (namespace: string) => unknown
-
-    /** Additional context data (e.g., filename for file-change hooks) */
-    [key: string]: unknown
-}
-
-/**
- * Runtime payload returned by plugins
- * 
- * CLI collects these and serializes without inspection.
- * The envelope structure is: { [namespace]: payload }
- */
-export interface RuntimePayload {
-    /** Plugin namespace (e.g., 'content', 'router') */
-    namespace: string
-    /** Opaque payload - CLI never inspects this */
-    payload: unknown
-}
-
-// ============================================
-// Hook Registry (Internal)
-// ============================================
-
-type HookHandler = (ctx: HookContext) => unknown | void | Promise<unknown | void>
-
-const hookRegistry = new Map<string, HookHandler[]>()
-
-/**
- * Register a hook handler
- * 
- * @internal Called by CLIBridgeAPI.on()
- */
-export function registerHook(hook: string, handler: HookHandler): void {
-    if (!hookRegistry.has(hook)) {
-        hookRegistry.set(hook, [])
-    }
-    hookRegistry.get(hook)!.push(handler)
-}
-
-/**
- * Clear all registered hooks
- * 
- * @internal Used for testing and cleanup
- */
-export function clearHooks(): void {
-    hookRegistry.clear()
-}
-
-// ============================================
-// Hook Execution (CLI-facing)
-// ============================================
-
-/**
- * Run all handlers for a hook (fire-and-forget)
- * 
- * CLI calls this for lifecycle events.
- * No return values are collected.
- * 
- * @param hook - Hook name to dispatch
- * @param ctx - Hook context
- */
-export async function runPluginHooks(hook: string, ctx: HookContext): Promise<void> {
-    const handlers = hookRegistry.get(hook) || []
-    for (const handler of handlers) {
-        try {
-            await handler(ctx)
-        } catch (error) {
-            console.error(`[Zenith] Hook "${hook}" error:`, error)
-        }
-    }
-}
-
-/**
- * Collect return values from all handlers for a hook
- * 
- * CLI calls this for 'cli:runtime:collect' to gather plugin payloads.
- * Only RuntimePayload-shaped returns are collected.
- * 
- * @param hook - Hook name to dispatch
- * @param ctx - Hook context
- * @returns Array of runtime payloads from plugins
- */
-export async function collectHookReturns(hook: string, ctx: HookContext): Promise<RuntimePayload[]> {
-    const handlers = hookRegistry.get(hook) || []
-    const results: RuntimePayload[] = []
-
-    for (const handler of handlers) {
-        try {
-            const result = await handler(ctx)
-
-            // Only collect properly shaped payloads
-            if (
-                result &&
-                typeof result === 'object' &&
-                'namespace' in result &&
-                'payload' in result &&
-                typeof (result as RuntimePayload).namespace === 'string'
-            ) {
-                results.push(result as RuntimePayload)
-            }
-        } catch (error) {
-            console.error(`[Zenith] Hook "${hook}" collection error:`, error)
-        }
-    }
-
-    return results
-}
-
-/**
- * Build runtime envelope from collected payloads
- * 
- * CLI calls this to serialize plugin data for injection.
- * CLI never inspects the envelope contents.
- * 
- * @param payloads - Array of runtime payloads from collectHookReturns
- * @returns Envelope object: { [namespace]: payload }
- */
-export function buildRuntimeEnvelope(payloads: RuntimePayload[]): Record<string, unknown> {
-    const envelope: Record<string, unknown> = {}
-
-    for (const { namespace, payload } of payloads) {
-        envelope[namespace] = payload
-    }
-
-    return envelope
-}
-
-// ============================================
-// Bridge API Factory
-// ============================================
-
-/**
- * Create a CLI Bridge API for plugin registration
- * 
- * CLI calls this once and passes to each plugin's registerCLI method.
- * 
- * @returns CLIBridgeAPI instance
- */
-export function createBridgeAPI(): CLIBridgeAPI {
-    return {
-        on: registerHook
-    }
-}

package/core/plugins/index.ts

@@ -1,7 +0,0 @@
-/**
- * Zenith Plugins
- * 
- * Public exports for plugin system
- */
-
-export { PluginRegistry, createPluginContext } from './registry';

package/core/plugins/registry.ts

@@ -1,126 +0,0 @@
-/**
- * Zenith Plugin Registry
- * 
- * Manages plugin registration and initialization
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * HOOK OWNERSHIP RULE (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * The plugin registry is part of core infrastructure.
- * It MUST remain plugin-agnostic:
- *   - No plugin-specific types
- *   - No plugin-specific logic
- *   - Generic data handling only
- * 
- * Plugins own their data structures; core provides the storage mechanism.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-
-import type { ZenithPlugin, PluginContext } from '../config/types';
-
-/**
- * Global plugin data store
- * 
- * Plugins store their data here using namespaced keys.
- * Core does not interpret this data - it just stores and serves it.
- */
-const pluginDataStore: Record<string, unknown[]> = {};
-
-/**
- * Get all plugin data (for runtime access)
- */
-export function getPluginData(): Record<string, unknown[]> {
-    return { ...pluginDataStore };
-}
-
-/**
- * Get plugin data by namespace
- */
-export function getPluginDataByNamespace(namespace: string): unknown[] {
-    return pluginDataStore[namespace] || [];
-}
-
-/**
- * Plugin registry for managing Zenith plugins
- */
-export class PluginRegistry {
-    private plugins = new Map<string, ZenithPlugin>();
-
-    /**
-     * Register a plugin
-     */
-    register(plugin: ZenithPlugin): void {
-        if (this.plugins.has(plugin.name)) {
-            console.warn(`[Zenith] Plugin "${plugin.name}" is already registered. Overwriting.`);
-        }
-        this.plugins.set(plugin.name, plugin);
-    }
-
-    /**
-     * Get a plugin by name
-     */
-    get(name: string): ZenithPlugin | undefined {
-        return this.plugins.get(name);
-    }
-
-    /**
-     * Check if a plugin is registered
-     */
-    has(name: string): boolean {
-        return this.plugins.has(name);
-    }
-
-    /**
-     * Get all registered plugins
-     */
-    all(): ZenithPlugin[] {
-        return Array.from(this.plugins.values());
-    }
-
-    /**
-     * Initialize all plugins with the provided context
-     */
-    async initAll(ctx: PluginContext): Promise<void> {
-        for (const plugin of this.plugins.values()) {
-            try {
-                await plugin.setup(ctx);
-                console.log(`[Zenith] Plugin "${plugin.name}" initialized`);
-            } catch (error: unknown) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.error(`[Zenith] Failed to initialize plugin "${plugin.name}":`, message);
-            }
-        }
-    }
-
-    /**
-     * Clear all registered plugins
-     */
-    clear(): void {
-        this.plugins.clear();
-        // Also clear plugin data
-        for (const key of Object.keys(pluginDataStore)) {
-            delete pluginDataStore[key];
-        }
-    }
-}
-
-/**
- * Create a plugin context for initialization
- * 
- * Uses a generic data setter that stores data by namespace.
- * Plugins define their own data structures internally.
- * 
- * @param projectRoot - Absolute path to the project root
- * @returns A PluginContext for plugin initialization
- */
-export function createPluginContext(projectRoot: string): PluginContext {
-    return {
-        projectRoot,
-        setPluginData: (namespace: string, data: unknown[]) => {
-            pluginDataStore[namespace] = data;
-        },
-        options: {}
-    };
-}
-