@zenithbuild/core 0.1.0 → 0.3.1

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/zen-build.ts

@@ -0,0 +1,2 @@
+import { runCLI } from '../cli/main'
+runCLI({ defaultCommand: 'build' })

package/bin/zen-dev.ts

@@ -0,0 +1,2 @@
+import { runCLI } from '../cli/main'
+runCLI({ defaultCommand: 'dev' })

package/bin/zen-preview.ts

@@ -0,0 +1,2 @@
+import { runCLI } from '../cli/main'
+runCLI({ defaultCommand: 'preview' })

package/bin/zenith.ts

@@ -0,0 +1,2 @@
+import { runCLI } from '../cli/main'
+runCLI()

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)
+    }
+}