@zenithbuild/cli 0.4.11 → 0.5.0-beta.2.3

package/dist/types/generate-env-dts.js

@@ -0,0 +1,52 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+
+export async function generateEnvDts(projectRoot) {
+    const content = `// .zenith/zenith-env.d.ts
+// Auto-generated by Zenith. Do not edit.
+
+export {};
+
+declare global {
+  namespace Zenith {
+    type Params = Record<string, string>;
+
+    interface LoadContext {
+      params: Params;
+      url: URL;
+      request: Request;
+      route: {
+        id: string;
+        file: string;
+        pattern: string;
+      };
+    }
+
+    interface ErrorState {
+      status?: number;
+      code?: string;
+      message: string;
+    }
+
+    type PageData = Record<string, unknown> & {
+      __zenith_error?: ErrorState;
+    };
+
+    type Load<T extends PageData = PageData> = (ctx: LoadContext) => Promise<T> | T;
+
+    type Renderable =
+      | string
+      | number
+      | boolean
+      | null
+      | undefined
+      | Renderable[]
+      | { __zenith_fragment: true };
+  }
+}
+`;
+
+    const outPath = join(projectRoot, '.zenith', 'zenith-env.d.ts');
+    await mkdir(dirname(outPath), { recursive: true });
+    await writeFile(outPath, content, 'utf8');
+}

package/dist/types/generate-routes-dts.js

@@ -0,0 +1,22 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+
+export async function generateRoutesDts(projectRoot, manifest) {
+    const routes = (manifest || []).map(r => r.path).filter(Boolean);
+    const typeDef = routes.length > 0
+        ? routes.map(r => '"' + r + '"').join(' | ')
+        : 'string';
+
+    const content = '// .zenith/zenith-routes.d.ts\\n' +
+        '// Auto-generated by Zenith. Do not edit.\\n\\n' +
+        'export {};\\n\\n' +
+        'declare global {\\n' +
+        '  namespace Zenith {\\n' +
+        '    type RoutePattern = ' + typeDef + ';\\n' +
+        '  }\\n' +
+        '}\\n';
+
+    const outPath = join(projectRoot, '.zenith', 'zenith-routes.d.ts');
+    await mkdir(dirname(outPath), { recursive: true });
+    await writeFile(outPath, content, 'utf8');
+}

package/dist/types/index.js

@@ -0,0 +1,34 @@
+import { generateEnvDts } from './generate-env-dts.js';
+import { generateRoutesDts } from './generate-routes-dts.js';
+import { join } from 'node:path';
+import { access, constants } from 'node:fs/promises';
+
+export async function ensureZenithTypes(projectRoot, manifest) {
+    try {
+        await generateEnvDts(projectRoot);
+        if (manifest) {
+            await generateRoutesDts(projectRoot, manifest);
+        }
+
+        // Check if tsconfig.json exists, if it does, check if .zenith is included
+        const tsconfigPath = join(projectRoot, 'tsconfig.json');
+        let hasTsConfig = false;
+        try {
+            await access(tsconfigPath, constants.F_OK);
+            hasTsConfig = true;
+        } catch {
+            hasTsConfig = false;
+        }
+
+        if (hasTsConfig) {
+            // In a real implementation this would parse the JSON and check "include".
+            // For now, we simply inform the user to include it if they haven't.
+            if (!globalThis.__zenithTypesWarned) {
+                console.warn('\\x1b[33m[zenith]\\x1b[0m For the best TypeScript experience, ensure ".zenith/**/*.d.ts" is in your tsconfig.json "include" array.');
+                globalThis.__zenithTypesWarned = true;
+            }
+        }
+    } catch (err) {
+        console.error('[zenith] Failed to generate type definitions:', err);
+    }
+}

package/dist/ui/env.js

@@ -0,0 +1,41 @@
+/**
+ * UI environment mode detection for deterministic CLI output.
+ */
+
+function flagEnabled(value) {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    const normalized = String(value).trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+
+/**
+ * @param {{ env?: Record<string, string | undefined>, stdout?: { isTTY?: boolean } }} runtime
+ */
+export function getUiMode(runtime = process) {
+    const env = runtime.env || {};
+    const tty = Boolean(runtime.stdout?.isTTY);
+    const ci = flagEnabled(env.CI);
+    const noUi = flagEnabled(env.ZENITH_NO_UI);
+    const noColor = env.NO_COLOR !== undefined && String(env.NO_COLOR).length >= 0;
+    const forceColor = flagEnabled(env.FORCE_COLOR);
+    const debug = flagEnabled(env.ZENITH_DEBUG);
+
+    const plain = noUi || ci || !tty;
+    const color = !plain && !noColor && (forceColor || tty);
+    const spinner = tty && !plain && !ci;
+
+    return {
+        plain,
+        color,
+        tty,
+        ci,
+        spinner,
+        debug
+    };
+}
+
+export function isUiPlain(runtime = process) {
+    return getUiMode(runtime).plain;
+}

package/dist/ui/format.js

@@ -0,0 +1,133 @@
+/**
+ * Deterministic text formatters for CLI UX.
+ */
+
+import { relative, sep } from 'node:path';
+
+const ANSI = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m'
+};
+
+function colorize(mode, token, text) {
+    if (!mode.color) {
+        return text;
+    }
+    return `${ANSI[token]}${text}${ANSI.reset}`;
+}
+
+export function formatHeading(mode, text) {
+    const label = mode.plain ? 'ZENITH CLI' : colorize(mode, 'bold', 'Zenith CLI');
+    return `${label} ${text}`.trim();
+}
+
+export function formatStep(mode, text) {
+    if (mode.plain) {
+        return `[zenith] INFO: ${text}`;
+    }
+    const bullet = colorize(mode, 'cyan', '•');
+    return `[zenith] ${bullet} ${text}`;
+}
+
+export function formatSummaryTable(mode, rows) {
+    if (!Array.isArray(rows) || rows.length === 0) {
+        return '';
+    }
+    const maxLabel = rows.reduce((acc, row) => Math.max(acc, String(row.label || '').length), 0);
+    return rows
+        .map((row) => {
+            const label = String(row.label || '').padEnd(maxLabel, ' ');
+            const value = String(row.value || '');
+            return `[zenith] ${label} : ${value}`;
+        })
+        .join('\n');
+}
+
+export function sanitizeErrorMessage(input) {
+    return String(input ?? '')
+        .replace(/\r/g, '')
+        .trim();
+}
+
+function normalizeFileLinePath(line) {
+    const match = line.match(/^(\s*File:\s+)(.+)$/);
+    if (!match) {
+        return line;
+    }
+
+    const prefix = match[1];
+    const filePath = match[2].trim();
+    if (!filePath.startsWith('/') && !/^[A-Za-z]:\\/.test(filePath)) {
+        return line;
+    }
+
+    const cwd = process.cwd();
+    const cwdWithSep = cwd.endsWith(sep) ? cwd : `${cwd}${sep}`;
+    if (filePath === cwd) {
+        return `${prefix}.`;
+    }
+    if (filePath.startsWith(cwdWithSep)) {
+        const relativePath = relative(cwd, filePath).replaceAll('\\', '/');
+        return `${prefix}${relativePath || '.'}`;
+    }
+
+    return line;
+}
+
+export function normalizeErrorMessagePaths(message) {
+    return String(message || '')
+        .split('\n')
+        .map((line) => normalizeFileLinePath(line))
+        .join('\n');
+}
+
+/**
+ * @param {unknown} err
+ */
+export function normalizeError(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    return new Error(sanitizeErrorMessage(err));
+}
+
+/**
+ * @param {unknown} err
+ * @param {{ plain: boolean, color: boolean, debug: boolean }} mode
+ */
+export function formatErrorBlock(err, mode) {
+    const normalized = normalizeError(err);
+    const maybe = /** @type {{ code?: unknown, phase?: unknown, kind?: unknown }} */ (normalized);
+    const kind = sanitizeErrorMessage(maybe.kind || maybe.code || 'CLI_ERROR');
+    const phase = maybe.phase ? sanitizeErrorMessage(maybe.phase) : '';
+    const code = maybe.code ? sanitizeErrorMessage(maybe.code) : '';
+    const rawMessage = sanitizeErrorMessage(normalized.message || String(normalized));
+    const message = normalizeErrorMessagePaths(rawMessage);
+
+    const lines = [];
+    lines.push('[zenith] ERROR: Command failed');
+    lines.push(`[zenith] Error Kind: ${kind}`);
+    if (phase) {
+        lines.push(`[zenith] Phase: ${phase}`);
+    }
+    if (code) {
+        lines.push(`[zenith] Code: ${code}`);
+    }
+    lines.push(`[zenith] Message: ${message}`);
+
+    if (mode.debug && normalized.stack) {
+        lines.push('[zenith] Stack:');
+        lines.push(...String(normalized.stack).split('\n').slice(0, 20));
+    }
+
+    return lines.join('\n');
+}
+
+export function containsAnsi(value) {
+    return /\x1b\[[0-9;]*m/.test(String(value || ''));
+}

package/dist/ui/logger.js

@@ -0,0 +1,105 @@
+import { formatErrorBlock, formatHeading, formatStep, formatSummaryTable } from './format.js';
+import { getUiMode } from './env.js';
+
+const SPINNER_FRAMES = ['-', '\\', '|', '/'];
+
+function write(out, text) {
+    out.write(`${text}\n`);
+}
+
+function createSpinner(mode, stderr) {
+    if (!mode.spinner) {
+        return {
+            start() { },
+            update() { },
+            stop() { },
+            succeed() { },
+            fail() { }
+        };
+    }
+
+    let interval = null;
+    let frame = 0;
+    let message = '';
+
+    const paint = () => {
+        const current = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+        stderr.write(`\r[zenith] ${current} ${message}`);
+        frame += 1;
+    };
+
+    const clear = () => {
+        stderr.write('\r');
+        stderr.write(' '.repeat(message.length + 12));
+        stderr.write('\r');
+    };
+
+    return {
+        start(nextMessage) {
+            message = String(nextMessage || '');
+            clearInterval(interval);
+            frame = 0;
+            paint();
+            interval = setInterval(paint, 80);
+        },
+        update(nextMessage) {
+            message = String(nextMessage || '');
+        },
+        stop() {
+            clearInterval(interval);
+            interval = null;
+            clear();
+        },
+        succeed(nextMessage) {
+            this.stop();
+            write(stderr, `[zenith] OK: ${nextMessage}`);
+        },
+        fail(nextMessage) {
+            this.stop();
+            write(stderr, `[zenith] ERROR: ${nextMessage}`);
+        }
+    };
+}
+
+/**
+ * @param {NodeJS.Process} runtime
+ */
+export function createLogger(runtime = process) {
+    const mode = getUiMode(runtime);
+    const stdout = runtime.stdout;
+    const stderr = runtime.stderr;
+    const spinner = createSpinner(mode, stderr);
+
+    return {
+        mode,
+        spinner,
+        heading(text) {
+            write(stdout, formatHeading(mode, text));
+        },
+        info(text) {
+            if (mode.plain) {
+                write(stdout, `[zenith] INFO: ${text}`);
+                return;
+            }
+            write(stdout, formatStep(mode, text));
+        },
+        success(text) {
+            write(stdout, `[zenith] OK: ${text}`);
+        },
+        warn(text) {
+            write(stderr, `[zenith] WARN: ${text}`);
+        },
+        error(err) {
+            write(stderr, formatErrorBlock(err, mode));
+        },
+        summary(rows) {
+            const table = formatSummaryTable(mode, rows);
+            if (table) {
+                write(stdout, table);
+            }
+        },
+        print(text) {
+            write(stdout, String(text));
+        }
+    };
+}

package/package.json

@@ -1,63 +1,35 @@
 {
   "name": "@zenithbuild/cli",
-  "version": "0.4.11",
-  "description": "CLI for Zenith framework - dev server, build tools, and plugin management",
+  "version": "0.5.0-beta.2.3",
+  "description": "Deterministic project orchestrator for Zenith framework",
+  "license": "MIT",
   "type": "module",
-  "bin": {
-    "zenith": "./dist/zenith.js",
-    "zen-dev": "./dist/zen-dev.js",
-    "zen-build": "./dist/zen-build.js",
-    "zen-preview": "./dist/zen-preview.js"
-  },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
   "exports": {
-    ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts"
-    }
+    ".": "./dist/index.js"
   },
   "files": [
-    "bin",
-    "src"
-  ],
-  "scripts": {
-    "dev": "bun run build && bin/zenith.ts dev",
-    "build": "bun build bin/zenith.ts bin/zen-dev.ts bin/zen-build.ts bin/zen-preview.ts --outdir dist --target bun --bundle && for f in dist/*.js; do echo '#!/usr/bin/env bun' | cat - \"$f\" > \"$f.tmp\" && mv \"$f.tmp\" \"$f\" && chmod +x \"$f\"; done",
-    "start": "bun run build && bun run dev",
-    "test": "bun test",
-    "release": "bun run scripts/release.ts",
-    "release:dry": "bun run scripts/release.ts --dry-run",
-    "release:patch": "bun run scripts/release.ts --bump=patch",
-    "release:minor": "bun run scripts/release.ts --bump=minor",
-    "release:major": "bun run scripts/release.ts --bump=major"
-  },
-  "keywords": [
-    "zenith",
-    "cli",
-    "framework",
-    "ssg",
-    "ssr"
+    "dist",
+    "README.md",
+    "LICENSE",
+    "dist/**",
+    "package.json"
   ],
-  "author": "Zenith Team",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:zenithbuild/zenith-cli.git"
-  },
   "publishConfig": {
     "access": "public"
   },
-  "private": false,
-  "peerDependencies": {
-    "@zenithbuild/core": "^1.2.15"
+  "scripts": {
+    "build": "mkdir -p dist && cp -a src/* dist/",
+    "test": "node --experimental-vm-modules $(node -e \"const path=require('node:path');const pkg=require.resolve('jest/package.json');process.stdout.write(path.join(path.dirname(pkg),'bin/jest.js'))\") --config jest.config.js --forceExit --runInBand",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@zenithbuild/compiler": "0.5.0-beta.2.3"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@jest/globals": "^30.2.0",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0"
   },
-  "dependencies": {
-    "@zenithbuild/compiler": "^1.0.16",
-    "@zenithbuild/router": "^1.0.8",
-    "picocolors": "^1.0.0"
-  }
-}
+  "private": false
+}

package/bin/zen-build.ts

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

package/bin/zen-dev.ts

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

package/bin/zen-preview.ts

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

package/bin/zenith.ts

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