@zenithbuild/cli 0.5.0-beta.2.6 → 0.6.2

package/dist/ui/logger.js

@@ -1,105 +1,270 @@
-import { formatErrorBlock, formatHeading, formatStep, formatSummaryTable } from './format.js';
+import {
+    formatErrorBlock,
+    formatHeading,
+    formatHint,
+    formatLine,
+    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) {
+const SILENT_MODE = {
+    plain: true,
+    color: false,
+    tty: false,
+    ci: true,
+    spinner: false,
+    debug: false,
+    logLevel: 'quiet'
+};
+
+function createNoopSpinner() {
+    return {
+        start() { },
+        update() { },
+        stop() { },
+        succeed() { },
+        fail() { }
+    };
+}
+
+function normalizeLevel(level) {
+    return level === 'quiet' || level === 'verbose' ? level : 'normal';
+}
+
+function shouldEmit(mode, tag) {
+    const level = normalizeLevel(mode.logLevel);
+    if (level === 'quiet') {
+        return tag === 'OK' || tag === 'WARN' || tag === 'ERR';
+    }
+    return true;
+}
+
+function createWriter(runtime, mode, sink = null) {
+    if (typeof sink === 'function') {
+        return sink;
+    }
+    return (stream, text) => {
+        const out = stream === 'stderr' ? runtime.stderr : runtime.stdout;
+        write(out, text);
+    };
+}
+
+function classifyChildLine(line) {
+    const trimmed = String(line || '').trim();
+    if (!trimmed) {
+        return null;
+    }
+
+    const vendorCache = trimmed.match(/^\[zenith\]\s+Vendor cache (hit|miss):\s+(.+)$/);
+    if (vendorCache) {
+        return {
+            tag: 'BUILD',
+            glyph: '•',
+            message: `vendor cache ${vendorCache[1]} (${vendorCache[2]})`,
+            onceKey: `vendor-cache:${vendorCache[1]}:${vendorCache[2]}`
+        };
+    }
+
+    const vendorBundle = trimmed.match(/^\[zenith\]\s+Vendor bundle:\s+(.+)$/);
+    if (vendorBundle) {
         return {
-            start() { },
-            update() { },
-            stop() { },
-            succeed() { },
-            fail() { }
+            tag: 'BUILD',
+            glyph: '•',
+            message: `vendor bundle ${vendorBundle[1]}`,
+            onceKey: `vendor-bundle:${vendorBundle[1]}`
         };
     }
 
-    let interval = null;
-    let frame = 0;
-    let message = '';
+    const bundler = trimmed.match(/^\[zenith-bundler\]\s*(.+)$/);
+    if (bundler) {
+        const message = bundler[1].trim();
+        const lower = message.toLowerCase();
+        if (lower.includes('warning')) {
+            return {
+                tag: 'WARN',
+                glyph: '⚠',
+                message,
+                onceKey: `bundler-warning:${message}`
+            };
+        }
+        if (lower.includes('error') || lower.includes('failed')) {
+            return {
+                tag: 'ERR',
+                glyph: '✖',
+                message
+            };
+        }
+        return {
+            tag: 'BUILD',
+            glyph: '•',
+            message
+        };
+    }
 
-    const paint = () => {
-        const current = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
-        stderr.write(`\r[zenith] ${current} ${message}`);
-        frame += 1;
-    };
+    const zenith = trimmed.match(/^\[zenith\]\s+(.+)$/);
+    if (zenith) {
+        return {
+            tag: 'BUILD',
+            glyph: '•',
+            message: zenith[1].trim(),
+            onceKey: `zenith-child:${zenith[1].trim()}`
+        };
+    }
 
-    const clear = () => {
-        stderr.write('\r');
-        stderr.write(' '.repeat(message.length + 12));
-        stderr.write('\r');
-    };
+    const compilerWarning = trimmed.match(/warning\[[^\]]+\]/i);
+    if (compilerWarning) {
+        return {
+            tag: 'WARN',
+            glyph: '⚠',
+            message: trimmed,
+            onceKey: `compiler-warning:${trimmed}`
+        };
+    }
 
     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}`);
-        }
+        tag: 'BUILD',
+        glyph: '•',
+        message: trimmed
     };
 }
 
-/**
- * @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);
+function createBaseLogger({ runtime = process, mode, sink = null, silent = false } = {}) {
+    const resolvedMode = mode || (silent ? SILENT_MODE : getUiMode(runtime));
+    const once = new Set();
+    const writeLine = createWriter(runtime, resolvedMode, sink);
+
+    function emit(tag, glyph, message, options = {}) {
+        if (options.onceKey) {
+            if (once.has(options.onceKey)) {
+                return false;
+            }
+            once.add(options.onceKey);
+        }
+
+        if (!shouldEmit(resolvedMode, tag)) {
+            return false;
+        }
+
+        const stream = tag === 'WARN' || tag === 'ERR' ? 'stderr' : 'stdout';
+        writeLine(stream, formatLine(resolvedMode, { glyph, tag, text: message }));
+        if (options.hint) {
+            writeLine(stream, formatHint(resolvedMode, options.hint));
+        }
+        return true;
+    }
 
     return {
-        mode,
-        spinner,
+        mode: resolvedMode,
+        spinner: createNoopSpinner(),
         heading(text) {
-            write(stdout, formatHeading(mode, text));
+            writeLine('stdout', formatHeading(resolvedMode, text));
+        },
+        print(text) {
+            writeLine('stdout', String(text));
         },
-        info(text) {
-            if (mode.plain) {
-                write(stdout, `[zenith] INFO: ${text}`);
-                return;
+        summary(rows, tag = 'BUILD') {
+            const table = formatSummaryTable(resolvedMode, rows, tag);
+            if (table) {
+                writeLine('stdout', table);
             }
-            write(stdout, formatStep(mode, text));
         },
-        success(text) {
-            write(stdout, `[zenith] OK: ${text}`);
+        dev(message, options = {}) {
+            return emit('DEV', '•', message, options);
         },
-        warn(text) {
-            write(stderr, `[zenith] WARN: ${text}`);
+        build(message, options = {}) {
+            return emit('BUILD', '•', message, options);
         },
-        error(err) {
-            write(stderr, formatErrorBlock(err, mode));
+        hmr(message, options = {}) {
+            return emit('HMR', '•', message, options);
         },
-        summary(rows) {
-            const table = formatSummaryTable(mode, rows);
-            if (table) {
-                write(stdout, table);
+        router(message, options = {}) {
+            return emit('ROUTER', '•', message, options);
+        },
+        css(message, options = {}) {
+            return emit('CSS', '•', message, options);
+        },
+        ok(message, options = {}) {
+            return emit('OK', '✓', message, options);
+        },
+        warn(message, options = {}) {
+            return emit('WARN', '⚠', message, options);
+        },
+        error(messageOrError, options = {}) {
+            const hasStructuredError = messageOrError instanceof Error || typeof messageOrError === 'object';
+            if (hasStructuredError && !options.hint && !options.onceKey && !options.error) {
+                writeLine('stderr', formatErrorBlock(messageOrError, resolvedMode));
+                return true;
+            }
+            const detail = options.error || messageOrError;
+            const formatted = detail instanceof Error || typeof detail === 'object'
+                ? formatErrorBlock(detail, resolvedMode)
+                : null;
+            if (formatted && (resolvedMode.logLevel === 'verbose' || resolvedMode.debug)) {
+                writeLine('stderr', formatted);
+                return true;
             }
+            const text = typeof messageOrError === 'string'
+                ? messageOrError
+                : (detail instanceof Error ? detail.message : String(detail || 'Command failed'));
+            return emit('ERR', '✖', text, options);
         },
-        print(text) {
-            write(stdout, String(text));
+        verbose(tag, message, options = {}) {
+            if (resolvedMode.logLevel !== 'verbose') {
+                return false;
+            }
+            return emit(tag, '•', message, options);
+        },
+        childLine(source, line, options = {}) {
+            const entry = classifyChildLine(line);
+            if (!entry) {
+                return false;
+            }
+            const streamHint = options.stream === 'stderr';
+            const isVerbose = resolvedMode.logLevel === 'verbose';
+            const isSeverity = entry.tag === 'WARN' || entry.tag === 'ERR';
+            if (!isVerbose && !isSeverity && options.showInfo === false) {
+                return false;
+            }
+            const onceKey = options.onceKey || entry.onceKey;
+            const message = options.prefix
+                ? `${options.prefix}${entry.message}`
+                : entry.message;
+            return emit(entry.tag, entry.glyph, message, {
+                ...options,
+                onceKey,
+                hint: options.hint,
+                stream: streamHint ? 'stderr' : undefined
+            });
+        },
+        info(message) {
+            return emit('DEV', '•', message);
+        },
+        success(message) {
+            return emit('OK', '✓', message);
         }
     };
 }
+
+export function createZenithLogger(runtime = process, options = {}) {
+    const mode = getUiMode(runtime);
+    if (options.logLevel) {
+        mode.logLevel = normalizeLevel(options.logLevel);
+    }
+    return createBaseLogger({ runtime, mode });
+}
+
+export function createSilentLogger() {
+    return createBaseLogger({
+        mode: SILENT_MODE,
+        sink: () => { },
+        silent: true
+    });
+}
+
+export function createLogger(runtime = process, options = {}) {
+    return createZenithLogger(runtime, options);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/cli",
-  "version": "0.5.0-beta.2.6",
+  "version": "0.6.2",
   "description": "Deterministic project orchestrator for Zenith framework",
   "license": "MIT",
   "type": "module",
@@ -24,7 +24,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@zenithbuild/compiler": "0.5.0-beta.2.6"
+    "@zenithbuild/compiler": "0.6.2",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
     "@jest/globals": "^30.2.0",
@@ -32,4 +33,4 @@
     "jest-environment-jsdom": "^30.2.0"
   },
   "private": false
-}
+}