@zenithbuild/cli 0.6.6 → 0.6.9

package/dist/ui/format.d.ts

@@ -0,0 +1,33 @@
+import pc from 'picocolors';
+import type { UiMode } from './env.js';
+type FormatTag = keyof typeof TAG_COLORS | string;
+interface SummaryRow {
+    label?: unknown;
+    value?: unknown;
+}
+declare const TAG_COLORS: {
+    DEV: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    BUILD: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    HMR: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    ROUTER: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    CSS: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    OK: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    WARN: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    ERR: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+};
+export declare function formatPrefix(mode: UiMode): string;
+export declare function formatLine(mode: UiMode, { glyph, tag, text }: {
+    glyph?: string;
+    tag?: FormatTag;
+    text?: unknown;
+}): string;
+export declare function formatStep(mode: UiMode, text: unknown, tag?: FormatTag): string;
+export declare function formatHint(mode: UiMode, text: unknown): string;
+export declare function formatHeading(mode: UiMode, text: unknown): string;
+export declare function formatSummaryTable(mode: UiMode, rows: SummaryRow[], tag?: FormatTag): string;
+export declare function sanitizeErrorMessage(input: unknown): string;
+export declare function normalizeErrorMessagePaths(message: string): string;
+export declare function normalizeError(err: unknown): Error;
+export declare function formatErrorBlock(err: unknown, mode: UiMode): string;
+export declare function containsAnsi(value: unknown): boolean;
+export {};

package/dist/ui/format.js

@@ -1,12 +1,10 @@
 import pc from 'picocolors';
 import { relative, sep } from 'node:path';
-
 const DEFAULT_PHASE = 'cli';
 const DEFAULT_FILE = '.';
-const DEFAULT_HINT_BASE = 'https://github.com/zenithbuild/zenith/blob/main/zenith-cli/CLI_CONTRACT.md';
+const DEFAULT_HINT_BASE = 'https://github.com/zenithbuild/framework/blob/master/packages/cli/CLI_CONTRACT.md';
 const PREFIX = '[zenith]';
 const TAG_WIDTH = 6;
-
 const TAG_COLORS = {
     DEV: (colors, value) => colors.cyan(value),
     BUILD: (colors, value) => colors.blue(value),
@@ -17,15 +15,12 @@ const TAG_COLORS = {
     WARN: (colors, value) => colors.bold(colors.yellow(value)),
     ERR: (colors, value) => colors.bold(colors.red(value))
 };
-
 function getColors(mode) {
-    return pc.createColors(Boolean(mode?.color));
+    return pc.createColors(Boolean(mode.color));
 }
-
 export function formatPrefix(mode) {
     return mode.color ? getColors(mode).dim(PREFIX) : PREFIX;
 }
-
 function colorizeTag(mode, tag) {
     const padded = String(tag || '').padEnd(TAG_WIDTH, ' ');
     if (!mode.color) {
@@ -35,7 +30,6 @@ function colorizeTag(mode, tag) {
     const colorizer = TAG_COLORS[tag] || ((_colors, value) => colors.white(value));
     return colorizer(colors, padded);
 }
-
 function colorizeGlyph(mode, glyph, tag) {
     if (!mode.color) {
         return glyph;
@@ -44,56 +38,47 @@ function colorizeGlyph(mode, glyph, tag) {
     const colorizer = TAG_COLORS[tag] || ((_colors, value) => value);
     return colorizer(colors, glyph);
 }
-
 export function formatLine(mode, { glyph = '•', tag = 'DEV', text = '' }) {
     return `${formatPrefix(mode)} ${colorizeGlyph(mode, glyph, tag)} ${colorizeTag(mode, tag)} ${String(text || '')}`;
 }
-
 export function formatStep(mode, text, tag = 'BUILD') {
     return formatLine(mode, { glyph: '•', tag, text });
 }
-
 export function formatHint(mode, text) {
     const body = `          hint: ${String(text || '').trim()}`;
     return mode.color ? getColors(mode).dim(body) : body;
 }
-
 export function formatHeading(mode, text) {
     const label = mode.color ? getColors(mode).bold('Zenith CLI') : 'Zenith CLI';
     return `${label} ${String(text || '').trim()}`.trim();
 }
-
 export function formatSummaryTable(mode, rows, tag = 'BUILD') {
     if (!Array.isArray(rows) || rows.length === 0) {
         return '';
     }
     return rows
         .map((row) => formatLine(mode, {
-            glyph: '•',
-            tag,
-            text: `${String(row.label || '')}: ${String(row.value || '')}`
-        }))
+        glyph: '•',
+        tag,
+        text: `${String(row.label || '')}: ${String(row.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();
     const normalized = normalizePathForDisplay(filePath);
     return `${prefix}${normalized}`;
 }
-
 function normalizePathForDisplay(filePath) {
     const value = String(filePath || '').trim();
     if (!value) {
@@ -102,7 +87,6 @@ function normalizePathForDisplay(filePath) {
     if (!value.startsWith('/') && !/^[A-Za-z]:\\/.test(value)) {
         return value;
     }
-
     const cwd = process.cwd();
     const cwdWithSep = cwd.endsWith(sep) ? cwd : `${cwd}${sep}`;
     if (value === cwd) {
@@ -112,10 +96,8 @@ function normalizePathForDisplay(filePath) {
         const relativePath = relative(cwd, value).replaceAll('\\', '/');
         return relativePath || DEFAULT_FILE;
     }
-
     return value;
 }
-
 function inferPhaseFromArgv() {
     const knownPhases = new Set(['build', 'dev', 'preview']);
     for (const arg of process.argv.slice(2)) {
@@ -125,12 +107,10 @@ function inferPhaseFromArgv() {
     }
     return DEFAULT_PHASE;
 }
-
 function extractFileFromMessage(message) {
     const match = String(message || '').match(/\bFile:\s+([^\n]+)/);
     return match ? match[1].trim() : '';
 }
-
 function formatHintUrl(code) {
     const slug = String(code || 'CLI_ERROR')
         .toLowerCase()
@@ -138,38 +118,27 @@ function formatHintUrl(code) {
         .replace(/^-+|-+$/g, '');
     return `${DEFAULT_HINT_BASE}#${slug || 'cli-error'}`;
 }
-
 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));
 }
-
 function firstMeaningfulLine(text) {
     return String(text || '')
         .split('\n')
         .map((line) => line.trim())
         .find((line) => line.length > 0) || '';
 }
-
-/**
- * @param {unknown} err
- * @param {{ plain: boolean, color: boolean, debug?: boolean, logLevel?: string }} mode
- */
 export function formatErrorBlock(err, mode) {
     const normalized = normalizeError(err);
-    const maybe = /** @type {{ code?: unknown, phase?: unknown, kind?: unknown, file?: unknown, hint?: unknown }} */ (normalized);
+    const maybe = normalized;
     const phase = maybe.phase ? sanitizeErrorMessage(maybe.phase) : inferPhaseFromArgv();
     const code = maybe.code
         ? sanitizeErrorMessage(maybe.code)
@@ -177,18 +146,14 @@ export function formatErrorBlock(err, mode) {
     const rawMessage = sanitizeErrorMessage(normalized.message || String(normalized));
     const message = normalizeErrorMessagePaths(rawMessage);
     const compactMessage = firstMeaningfulLine(message) || 'Command failed';
-    const file = normalizePathForDisplay(
-        sanitizeErrorMessage(maybe.file || extractFileFromMessage(message) || DEFAULT_FILE)
-    );
+    const file = normalizePathForDisplay(sanitizeErrorMessage(maybe.file || extractFileFromMessage(message) || DEFAULT_FILE));
     const hint = sanitizeErrorMessage(maybe.hint || formatHintUrl(code));
-
     if (mode.logLevel !== 'verbose' && !mode.debug) {
         return [
             formatLine(mode, { glyph: '✖', tag: 'ERR', text: compactMessage }),
             formatHint(mode, hint)
         ].join('\n');
     }
-
     const lines = [];
     lines.push(formatLine(mode, { glyph: '✖', tag: 'ERR', text: compactMessage }));
     lines.push(formatHint(mode, hint || formatHintUrl(code)));
@@ -196,15 +161,12 @@ export function formatErrorBlock(err, mode) {
     lines.push(`${formatPrefix(mode)}     phase: ${phase || DEFAULT_PHASE}`);
     lines.push(`${formatPrefix(mode)}     file: ${file || DEFAULT_FILE}`);
     lines.push(`${formatPrefix(mode)}     detail: ${message}`);
-
     if (mode.debug && normalized.stack) {
         lines.push(`${formatPrefix(mode)}     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.d.ts

@@ -0,0 +1,59 @@
+import { type UiMode, type UiRuntime } from './env.js';
+type LoggerTag = 'DEV' | 'BUILD' | 'HMR' | 'ROUTER' | 'CSS' | 'OK' | 'WARN' | 'ERR' | string;
+type LoggerStream = 'stdout' | 'stderr';
+interface LoggerRuntime extends UiRuntime {
+    stdout: {
+        isTTY?: boolean;
+        write: (value: string) => void;
+    };
+    stderr: {
+        isTTY?: boolean;
+        write: (value: string) => void;
+    };
+}
+interface Spinner {
+    start(): void;
+    update(): void;
+    stop(): void;
+    succeed(): void;
+    fail(): void;
+}
+interface SummaryRow {
+    label?: unknown;
+    value?: unknown;
+}
+interface EmitOptions {
+    onceKey?: string;
+    hint?: string;
+    stream?: LoggerStream;
+    showInfo?: boolean;
+    prefix?: string;
+    error?: unknown;
+}
+export interface ZenithLogger {
+    mode: UiMode;
+    spinner: Spinner;
+    heading(text: string): void;
+    print(text: string): void;
+    summary(rows: SummaryRow[], tag?: LoggerTag): void;
+    dev(message: string, options?: EmitOptions): boolean;
+    build(message: string, options?: EmitOptions): boolean;
+    hmr(message: string, options?: EmitOptions): boolean;
+    router(message: string, options?: EmitOptions): boolean;
+    css(message: string, options?: EmitOptions): boolean;
+    ok(message: string, options?: EmitOptions): boolean;
+    warn(message: string, options?: EmitOptions): boolean;
+    error(messageOrError: unknown, options?: EmitOptions): boolean;
+    verbose(tag: LoggerTag, message: string, options?: EmitOptions): boolean;
+    childLine(source: string, line: string, options?: EmitOptions): boolean;
+    info(message: string): boolean;
+    success(message: string): boolean;
+}
+export declare function createZenithLogger(runtime?: LoggerRuntime, options?: {
+    logLevel?: string;
+}): ZenithLogger;
+export declare function createSilentLogger(): ZenithLogger;
+export declare function createLogger(runtime?: LoggerRuntime, options?: {
+    logLevel?: string;
+}): ZenithLogger;
+export {};

package/dist/ui/logger.js

@@ -1,16 +1,8 @@
-import {
-    formatErrorBlock,
-    formatHeading,
-    formatHint,
-    formatLine,
-    formatSummaryTable
-} from './format.js';
+import { formatErrorBlock, formatHeading, formatHint, formatLine, formatSummaryTable } from './format.js';
 import { getUiMode } from './env.js';
-
 function write(out, text) {
     out.write(`${text}\n`);
 }
-
 const SILENT_MODE = {
     plain: true,
     color: false,
@@ -20,7 +12,6 @@ const SILENT_MODE = {
     debug: false,
     logLevel: 'quiet'
 };
-
 function createNoopSpinner() {
     return {
         start() { },
@@ -30,11 +21,9 @@ function createNoopSpinner() {
         fail() { }
     };
 }
-
 function normalizeLevel(level) {
     return level === 'quiet' || level === 'verbose' ? level : 'normal';
 }
-
 function shouldEmit(mode, tag) {
     const level = normalizeLevel(mode.logLevel);
     if (level === 'quiet') {
@@ -42,7 +31,6 @@ function shouldEmit(mode, tag) {
     }
     return true;
 }
-
 function createWriter(runtime, mode, sink = null) {
     if (typeof sink === 'function') {
         return sink;
@@ -52,13 +40,11 @@ function createWriter(runtime, mode, sink = null) {
         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 {
@@ -68,7 +54,6 @@ function classifyChildLine(line) {
             onceKey: `vendor-cache:${vendorCache[1]}:${vendorCache[2]}`
         };
     }
-
     const vendorBundle = trimmed.match(/^\[zenith\]\s+Vendor bundle:\s+(.+)$/);
     if (vendorBundle) {
         return {
@@ -78,7 +63,6 @@ function classifyChildLine(line) {
             onceKey: `vendor-bundle:${vendorBundle[1]}`
         };
     }
-
     const bundler = trimmed.match(/^\[zenith-bundler\]\s*(.+)$/);
     if (bundler) {
         const message = bundler[1].trim();
@@ -104,7 +88,6 @@ function classifyChildLine(line) {
             message
         };
     }
-
     const zenith = trimmed.match(/^\[zenith\]\s+(.+)$/);
     if (zenith) {
         return {
@@ -114,7 +97,6 @@ function classifyChildLine(line) {
             onceKey: `zenith-child:${zenith[1].trim()}`
         };
     }
-
     const compilerWarning = trimmed.match(/warning\[[^\]]+\]/i);
     if (compilerWarning) {
         return {
@@ -124,19 +106,16 @@ function classifyChildLine(line) {
             onceKey: `compiler-warning:${trimmed}`
         };
     }
-
     return {
         tag: 'BUILD',
         glyph: '•',
         message: trimmed
     };
 }
-
 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)) {
@@ -144,11 +123,9 @@ function createBaseLogger({ runtime = process, mode, sink = null, silent = 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) {
@@ -156,7 +133,6 @@ function createBaseLogger({ runtime = process, mode, sink = null, silent = false
         }
         return true;
     }
-
     return {
         mode: resolvedMode,
         spinner: createNoopSpinner(),
@@ -218,12 +194,11 @@ function createBaseLogger({ runtime = process, mode, sink = null, silent = false
             }
             return emit(tag, '•', message, options);
         },
-        childLine(source, line, 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) {
@@ -236,8 +211,7 @@ function createBaseLogger({ runtime = process, mode, sink = null, silent = false
             return emit(entry.tag, entry.glyph, message, {
                 ...options,
                 onceKey,
-                hint: options.hint,
-                stream: streamHint ? 'stderr' : undefined
+                hint: options.hint
             });
         },
         info(message) {
@@ -248,7 +222,6 @@ function createBaseLogger({ runtime = process, mode, sink = null, silent = false
         }
     };
 }
-
 export function createZenithLogger(runtime = process, options = {}) {
     const mode = getUiMode(runtime);
     if (options.logLevel) {
@@ -256,7 +229,6 @@ export function createZenithLogger(runtime = process, options = {}) {
     }
     return createBaseLogger({ runtime, mode });
 }
-
 export function createSilentLogger() {
     return createBaseLogger({
         mode: SILENT_MODE,
@@ -264,7 +236,6 @@ export function createSilentLogger() {
         silent: true
     });
 }
-
 export function createLogger(runtime = process, options = {}) {
     return createZenithLogger(runtime, options);
 }

package/dist/version-check.d.ts

@@ -0,0 +1,54 @@
+type PackageKey = 'core' | 'compiler' | 'runtime' | 'router' | 'bundlerPackage';
+type CompatibilityStatus = 'ok' | 'warn';
+interface BundlerVersionResult {
+    version: string | null;
+    path: string;
+    rawOutput: string;
+    ok: boolean;
+}
+interface VersionIssue {
+    code: string;
+    summary: string;
+    message: string;
+    hint: string;
+    fixCommand: string;
+}
+export type ZenithVersions = Record<PackageKey, string | null> & {
+    cli: string;
+    projectCli: string | null;
+    bundlerBinary: string | null;
+    bundlerBinPath: string;
+    bundlerBinRawOutput: string;
+    targetVersion: string | null;
+    projectRoot?: string | null;
+};
+interface CompatibilityResult {
+    status: CompatibilityStatus;
+    issues: VersionIssue[];
+    details: {
+        targetVersion: string;
+        versions: Record<string, unknown>;
+        summary: string;
+    };
+}
+interface VersionCheckLogger {
+    warn: (message: string, options?: {
+        onceKey?: string;
+        hint?: string;
+    }) => void;
+    verbose: (tag: string, message: string) => void;
+}
+export declare function compareVersions(leftVersion: string | null | undefined, rightVersion: string | null | undefined): number;
+export declare function getBundlerVersion(bundlerBinPath: string | null | undefined): BundlerVersionResult;
+export declare function getLocalZenithVersions({ projectRoot, bundlerBinPath }?: {
+    projectRoot?: string | null;
+    bundlerBinPath?: string | null;
+}): ZenithVersions;
+export declare function checkCompatibility(versions: Partial<ZenithVersions>): CompatibilityResult;
+export declare function maybeWarnAboutZenithVersionMismatch({ projectRoot, logger, command, bundlerBinPath }?: {
+    projectRoot?: string | null;
+    logger?: VersionCheckLogger | null;
+    command?: string;
+    bundlerBinPath?: string | null;
+}): Promise<CompatibilityResult>;
+export {};