@zenithbuild/core 0.1.0 → 0.3.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Judah Sullivan
+Copyright (c) 2026 Zenith Team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,55 +1,39 @@
+# @zenithbuild/core ⚡
 
-# Zenith Framework
+The heart of the Zenith framework. High-performance reactive runtime, compiler, and build primitives.
 
----
+## Overview
 
-## README.md
+Zenith is a modern reactive web framework designed for maximum performance and developer experience. The core package contains the essential building blocks:
+- **Compiler**: Transforms `.zen` files into optimized JavaScript.
+- **Runtime**: A lightweight, efficient reactive system for the browser.
+- **Router**: Lightweight client-side routing.
+- **Build Primitives**: Tools for dev servers and production builds.
 
-### What is Zenith?
+## Key Components
 
-Zenith is an **HTML-first, web-native framework** focused on predictable rendering, persistent navigation state, and minimal JavaScript by default.
+### 1. Compiler (`/compiler`)
+The Zenith compiler handles parsing and transforming Single File Components (`.zen`). It leverages `parse5` for robust HTML parsing and generates highly optimized render functions.
 
-Zenith treats HTML as the source of truth. Behavior is inferred through static analysis rather than developer flags like `use client` or `client-only`.
+### 2. Runtime (`/runtime`)
+Our runtime is designed to be minimal. It manages the reactive cycle, efficient DOM updates, and lifecycle management (like `zenOnMount`).
 
-The framework is currently **under active construction**. Core goals and constraints are intentionally defined early to avoid runtime complexity and hydration pitfalls seen in existing frameworks.
+### 3. Server (`/bin/zen-dev`, `/bin/zen-build`)
+Low-level binaries for orchestrating development and production environments.
 
-### Core Principles (Locked In)
+## Architecture
 
-* HTML-first authoring
-* `.zenith` file format
-* Optional `<script>` and `<style>` blocks
-* No required `<template>` wrapper
-* Automatic client/runtime detection
-* Navigation lifecycle as a first-class primitive
-* Persistent layouts across navigation
-* VDOM used intentionally (not everywhere)
+Zenith follows a "Compiler-First" philosophy. We shift as much work as possible to build time, keeping the client-side bundle lean and fast.
 
-### What Zenith Is (Currently)
+## Usage (Internal)
 
-* A compiler that transforms `.zenith` files into optimized runtime modules
-* A navigation-aware runtime with lifecycle hooks
-* A layout + document ownership system
-
-### What Zenith Is Not (Yet)
-
-* A finished production framework
-* A replacement for all React/Vue use-cases
-* An SSR platform (planned, not finalized)
-
-### High-Level Architecture
+This package is typically consumed by the Zenith CLI and other ecosystem tools.
 
+```typescript
+import { compile } from '@zenithbuild/core/compiler';
+// ... compile logic
 ```
-.zenith files
-   ↓
-Compiler (parse → analyze → compose → generate)
-   ↓
-Runtime (navigation + rendering)
-   ↓
-DOM
-```
-
-### Status
 
-Zenith is in the **foundation phase**. APIs may change rapidly.
+## License
 
-### [Contributing](./docs/CONTRIBUTING.md)
+MIT

package/bin/cli-source.ts

@@ -0,0 +1,81 @@
+/**
+ * @zenith/cli - Entry Point
+ * 
+ * Main executable for the Zenith CLI.
+ * Handles both "zenith <command>" and direct alias calls (zenith-dev, etc.)
+ */
+
+import process from 'node:process'
+import path from 'node:path'
+import { getCommand, showHelp, placeholderCommands } from '../cli/commands/index'
+import * as logger from '../cli/utils/logger'
+
+async function main() {
+    const args = process.argv.slice(2)
+    const invokedAs = path.basename(process.argv[1] || '')
+
+    let commandName: string | undefined = args[0]
+    let commandArgs = args.slice(1)
+
+    // Handle aliases (e.g. zenith-dev, zen-dev)
+    if (invokedAs.includes('dev')) {
+        commandName = 'dev'
+        commandArgs = args
+    } else if (invokedAs.includes('build')) {
+        commandName = 'build'
+        commandArgs = args
+    } else if (invokedAs.includes('preview')) {
+        commandName = 'preview'
+        commandArgs = args
+    }
+
+    if (!commandName || commandName === '--help' || commandName === '-h') {
+        showHelp()
+        process.exit(0)
+    }
+
+    // Filter out options from commandArgs for simple command parsing if needed
+    // However, most commands parse their own options
+    const filteredArgs = commandArgs.filter((a: string) => !a.startsWith('--'))
+
+    // Parse options (--key value format)
+    const options: 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('--')) {
+                options[key] = value
+                i++
+            } else {
+                options[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, options)
+    } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err)
+        logger.error(message)
+        process.exit(1)
+    }
+}
+
+main()

package/cli/commands/add.ts

@@ -0,0 +1,37 @@
+/**
+ * @zenith/cli - Add Command
+ * 
+ * Registers a plugin in the project
+ */
+
+import { requireProject } from '../utils/project'
+import { addPlugin, hasPlugin } from '../utils/plugin-manager'
+import * as logger from '../utils/logger'
+
+export interface AddOptions {
+    options?: Record<string, unknown>
+}
+
+export async function add(pluginName: string, options: AddOptions = {}): Promise<void> {
+    requireProject()
+
+    logger.header('Add Plugin')
+
+    if (!pluginName) {
+        logger.error('Plugin name required. Usage: zenith add <plugin>')
+        process.exit(1)
+    }
+
+    if (hasPlugin(pluginName)) {
+        logger.warn(`Plugin "${pluginName}" is already registered`)
+        return
+    }
+
+    const success = addPlugin(pluginName, options.options)
+
+    if (success) {
+        logger.info(`Plugin "${pluginName}" has been registered.`)
+        logger.info('Note: You may need to install the package manually:')
+        logger.log(`  bun add @zenith/plugin-${pluginName}`)
+    }
+}

package/cli/commands/build.ts

@@ -0,0 +1,37 @@
+/**
+ * @zenith/cli - Build Command
+ * 
+ * Builds the application for production using SSG.
+ */
+
+import path from 'path'
+import { requireProject } from '../utils/project'
+import * as logger from '../utils/logger'
+import { buildSSG } from '../../compiler/ssg-build'
+
+export interface BuildOptions {
+    outDir?: string
+}
+
+export async function build(options: BuildOptions = {}): Promise<void> {
+    const project = requireProject()
+    const outDir = options.outDir || project.distDir
+
+    logger.header('Zenith Build')
+    logger.log(`Source: ${project.pagesDir}`)
+    logger.log(`Output: ${outDir}`)
+
+    try {
+        buildSSG({
+            pagesDir: project.pagesDir,
+            outDir: outDir,
+            baseDir: project.root
+        })
+        logger.success('Build complete!')
+
+    } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err)
+        logger.error(`Build failed: ${message}`)
+        process.exit(1)
+    }
+}