kailogger 1.0.0-dark.red → 1.0.2

package/src/core/Logger.ts

@@ -1,80 +1,456 @@
-import chalk from 'chalk';
-import { paint, GradientEngine } from '../styles/gradients';
+
+import * as fs from 'fs';
+import { paint, palettes, ThemeName } from '../styles/palettes';
+import { KaiChroma } from '../styles/KaiChroma';
 import { KaiSpinner } from '../utils/spinner';
-import { ThemeName } from '../styles/palettes';
+import { KaiProgress } from '../utils/progress';
+import { KaiTable } from '../utils/table';
+import { KaiPrompt } from '../utils/prompt';
+import { KaiSelection } from '../utils/selection';
+import { KaiJson } from '../utils/json';
+import { PrettyError } from '../utils/prettyError';
+import { stripAnsi } from '../utils/stripAnsi';
+import { config } from './Config';
+import { ScopedLogger } from './Scope';
+import { KaiTimer } from '../features/Timer';
+import { KaiTree } from '../features/Tree';
+import { KaiDiff } from '../features/Diff';
+import { KaiChart } from '../features/Chart';
+import { KaiNotify } from '../features/Notify';
+import { KaiScreenshot } from '../features/Screenshot';
+import { KaiEncrypt } from '../features/Encrypt';
+import { KaiSound } from '../features/Sound';
+import { LogLevel, LOG_LEVEL_PRIORITY, Transport, KaiConfig } from '../types';
+import { FileTransport, FileTransportOptions } from '../transports/FileTransport';
+import { WebhookTransport, WebhookTransportOptions } from '../transports/WebhookTransport';
+
+interface LoggerOptions {
+    theme?: ThemeName;
+    level?: LogLevel;
+    logFile?: string;
+    silent?: boolean;
+    timestamp?: 'ISO' | 'locale' | 'relative' | 'none';
+}
 
-type LogLevel = 'success' | 'error' | 'warning' | 'info' | 'debug';
 export class KaiLogger {
     private spinner = new KaiSpinner();
-    constructor(public theme: ThemeName = 'zen') {
-        paint.setTheme(theme);
+    private timer = new KaiTimer();
+    private logFilePath?: string;
+    private buffer: string[] = [];
+    private startTime: number = Date.now();
+
+    public theme: ThemeName;
+    public level: LogLevel;
+    public silent: boolean;
+    public timestampFormat: 'ISO' | 'locale' | 'relative' | 'none';
+
+    constructor(options: LoggerOptions | ThemeName = 'zen') {
+        if (typeof options === 'string') {
+            this.theme = options;
+            this.level = 'debug';
+            this.silent = false;
+            this.timestampFormat = 'locale';
+        } else {
+            this.theme = options.theme || 'zen';
+            this.level = options.level || 'debug';
+            this.logFilePath = options.logFile;
+            this.silent = options.silent || false;
+            this.timestampFormat = options.timestamp || 'locale';
+        }
+        paint.setTheme(this.theme);
+    }
+
+    // ========== CONFIGURATION ==========
+    
+    public configure(options: Partial<LoggerOptions>): void {
+        if (options.theme) this.setTheme(options.theme);
+        if (options.level) this.level = options.level;
+        if (options.logFile) this.logFilePath = options.logFile;
+        if (options.silent !== undefined) this.silent = options.silent;
+        if (options.timestamp) this.timestampFormat = options.timestamp;
     }
-    public setTheme(theme: ThemeName) {
+
+    public setTheme(theme: ThemeName): void {
         this.theme = theme;
         paint.setTheme(theme);
     }
-    private getTime() {
-        const date = new Date();
-        return chalk.gray(`[${date.toLocaleTimeString()}]`);
+
+    public setLevel(level: LogLevel): void {
+        this.level = level;
+    }
+
+    public setSilent(silent: boolean): void {
+        this.silent = silent;
+    }
+
+    // ========== TRANSPORTS ==========
+
+    public addFileTransport(options: FileTransportOptions): void {
+        config.addTransport(new FileTransport(options));
+    }
+
+    public addWebhookTransport(options: WebhookTransportOptions): void {
+        config.addTransport(new WebhookTransport(options));
+    }
+
+    public removeTransport(name: string): void {
+        config.removeTransport(name);
+    }
+
+    // ========== SCOPED LOGGERS ==========
+
+    public scope(name: string): ScopedLogger {
+        return new ScopedLogger(this, name);
+    }
+
+    // ========== TIMESTAMPS ==========
+
+    private getTime(): string {
+        if (this.timestampFormat === 'none') return '';
+        
+        const now = new Date();
+        
+        switch (this.timestampFormat) {
+            case 'ISO':
+                return `[${now.toISOString()}]`;
+            case 'relative':
+                const elapsed = Date.now() - this.startTime;
+                const seconds = (elapsed / 1000).toFixed(1);
+                return `[+${seconds}s]`;
+            case 'locale':
+            default:
+                return `[${now.toLocaleTimeString()}]`;
+        }
+    }
+
+    // ========== LEVEL CHECKING ==========
+
+    private shouldLog(level: LogLevel): boolean {
+        if (this.silent) return false;
+        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+    }
+
+    // ========== FILE & TRANSPORT LOGGING ==========
+
+    private logToFile(level: string, message: string): void {
+        if (this.logFilePath) {
+            const cleanMsg = stripAnsi(message);
+            const logLine = `${this.getTime()} [${level.toUpperCase()}] ${cleanMsg}\n`;
+            fs.appendFileSync(this.logFilePath, logLine);
+        }
+
+        const transports = config.get('transports') || [];
+        transports.forEach(t => t.log(level as LogLevel, message));
+    }
+
+    private addToBuffer(level: string, message: string): void {
+        this.buffer.push(`${this.getTime()} [${level.toUpperCase()}] ${message}`);
+    }
+
+    public getBuffer(): string[] {
+        return [...this.buffer];
+    }
+
+    public clearBuffer(): void {
+        this.buffer = [];
+    }
+
+    // ========== CORE LOGGING ==========
+
+    private print(level: LogLevel, label: string, message: string, ...args: any[]): void {
+        if (!this.shouldLog(level)) {
+            this.addToBuffer(level, message);
+            return;
+        }
+
+        this.stopSpinner();
+        // Accedemos safe a paint.colors[level]
+        const colors = (paint.colors as any)[level] as string[]; 
+        const time = this.timestampFormat !== 'none' ? KaiChroma.hex('#666666', this.getTime()) + ' ' : '';
+        const badge = paint.apply(` ${label.padEnd(7)} `, colors);
+        const output = `${time}${badge} ${message}`;
+        
+        console.log(output, ...args);
+        
+        const fileMsg = [message, ...args.map(a => typeof a === 'object' ? JSON.stringify(a) : a)].join(' ');
+        this.logToFile(level, fileMsg);
+        this.addToBuffer(level, fileMsg);
+    }
+
+    public success(message: string, ...args: any[]): void {
+        this.print('success', '✔ SUCCESS', message, ...args);
+    }
+
+    public error(message: string | Error, ...args: any[]): void {
+        if (!this.shouldLog('error')) return;
+        
+        if (message instanceof Error) {
+            this.stopSpinner();
+            PrettyError.handle(message, paint.colors);
+            this.logToFile('error', message.toString());
+            this.addToBuffer('error', message.toString());
+        } else {
+            this.print('error', '✖ ERROR', message, ...args);
+        }
+    }
+
+    public warning(message: string, ...args: any[]): void {
+        this.print('warning', '⚠ WARN', message, ...args);
+    }
+
+    public info(message: string, ...args: any[]): void {
+        this.print('info', 'ℹ INFO', message, ...args);
+    }
+
+    public debug(message: string, ...args: any[]): void {
+        this.print('debug', '⚙ DEBUG', message, ...args);
+    }
+
+    public log(message: string): void {
+        if (this.silent) return;
+        this.stopSpinner();
+        const time = this.timestampFormat !== 'none' ? KaiChroma.hex('#666666', this.getTime()) + ' ' : '';
+        console.log(`${time}${message}`);
+        this.logToFile('log', message);
+    }
+
+    // ========== CUSTOM BADGE ==========
+
+    public custom(badge: string, color: string, message: string, ...args: any[]): void {
+        if (this.silent) return;
+        this.stopSpinner();
+        const time = this.timestampFormat !== 'none' ? KaiChroma.hex('#666666', this.getTime()) + ' ' : '';
+        const styledBadge = KaiChroma.bgHex(color, ` ${badge.toUpperCase().padEnd(7)} `);
+        console.log(`${time}${styledBadge} ${message}`, ...args);
+        this.logToFile(badge, message);
+    }
+
+    // ========== BOX ==========
+
+    public box(title: string, message: string): void {
+        if (this.silent) return;
+        this.stopSpinner();
+        const width = Math.max(message.length, title.length) + 4;
+        const border = paint.apply('─'.repeat(width), paint.colors.info);
+        const topLeft = paint.apply('╭', paint.colors.info);
+        const topRight = paint.apply('╮', paint.colors.info);
+        const bottomLeft = paint.apply('╰', paint.colors.info);
+        const bottomRight = paint.apply('╯', paint.colors.info);
+        const side = paint.apply('│', paint.colors.info);
+
+        console.log(`${topLeft}${border}${topRight}`);
+        console.log(`${side} ${paint.apply(title.padEnd(width - 2), paint.colors.success)} ${side}`);
+        console.log(`${side}${paint.apply('─'.repeat(width), paint.colors.debug)}${side}`);
+        console.log(`${side} ${message.padEnd(width - 2)} ${side}`);
+        console.log(`${bottomLeft}${border}${bottomRight}`);
+        
+        this.logToFile('box', `${title}: ${message}`);
+    }
+
+    // ========== SPINNER ==========
+
+    public await(message: string): void {
+        if (this.silent) return;
+        this.spinner.start(message, paint.colors.info[0]);
+    }
+
+    public stop(message?: string): void {
+        this.spinner.stop('✔', message, paint.colors.success[1]);
+        if (message) this.logToFile('stop', message);
+    }
+
+    private stopSpinner(): void {
+        this.spinner.stop();
+    }
+
+    // ========== PROGRESS ==========
+
+    public createProgress(total: number, width?: number): KaiProgress {
+        return new KaiProgress(total, width, this.theme);
+    }
+
+    // ========== TABLE ==========
+
+    public table(data: any[]): void {
+        if (this.silent) return;
+        this.stopSpinner();
+        KaiTable.print(data, paint.colors);
+        this.logToFile('table', JSON.stringify(data));
+    }
+
+    // ========== JSON ==========
+
+    public json(data: any): void {
+        if (this.silent) return;
+        this.stopSpinner();
+        KaiJson.print(data, paint.colors);
+        this.logToFile('json', JSON.stringify(data));
+    }
+
+    // ========== TREE ==========
+
+    public tree(data: any): void {
+        if (this.silent) return;
+        this.stopSpinner();
+        KaiTree.print(data, paint.colors);
+        this.logToFile('tree', JSON.stringify(data));
+    }
+
+    // ========== DIFF ==========
+
+    public diff(before: any, after: any): void {
+        if (this.silent) return;
+        this.stopSpinner();
+        KaiDiff.print(before, after, paint.colors);
+        this.logToFile('diff', JSON.stringify({ before, after }));
+    }
+
+    // ========== TIMER ==========
+
+    public time(label: string): void {
+        this.timer.time(label);
+    }
+
+    public timeEnd(label: string): number | null {
+        if (this.silent) return null;
+        return this.timer.timeEnd(label, paint.colors);
+    }
+
+    // ========== PROMPTS ==========
+
+    public async ask(question: string): Promise<string> {
+        this.stopSpinner();
+        // Pasamos theme.info colors, asumimos que prompt maneja esto
+        const answer = await KaiPrompt.ask(question, paint.colors);
+        this.logToFile('ask', `${question} -> ${answer}`);
+        return answer;
+    }
+
+    public async confirm(question: string): Promise<boolean> {
+        this.stopSpinner();
+        const answer = await KaiPrompt.confirm(question, paint.colors);
+        this.logToFile('confirm', `${question} -> ${answer}`);
+        return answer;
     }
-    private format(level: LogLevel, message: string, ...args: any[]) {
-        const colors = paint.text[level];
-        const badge = paint.apply(` ${level.toUpperCase()} `, colors);
-        const formattedMsg = paint.apply(message, colors);
-        console.log(`${this.getTime()} ${chalk.bold(badge)} ${message}`, ...args);
+
+    public async select(question: string, options: string[]): Promise<string> {
+        this.stopSpinner();
+        const answer = await KaiSelection.select(question, options, paint.colors);
+        this.logToFile('select', `${question} -> ${answer}`);
+        return answer;
     }
-    public success(message: string, ...args: any[]) {
+
+    public async multiselect(question: string, options: string[]): Promise<string[]> {
         this.stopSpinner();
-        const colors = paint.text.success;
-        console.log(`${this.getTime()} ${paint.apply(' ✔ SUCCESS ', colors)} ${message}`, ...args);
+        const answer = await KaiSelection.multiselect(question, options, paint.colors);
+        this.logToFile('multiselect', `${question} -> ${answer.join(', ')}`);
+        return answer;
     }
-    public error(message: string, ...args: any[]) {
+
+    // ========== CHARTS ==========
+
+    public chart(data: { label: string; value: number }[], options?: { width?: number; showValues?: boolean }): void {
+        if (this.silent) return;
         this.stopSpinner();
-        const colors = paint.text.error;
-        console.log(`${this.getTime()} ${paint.apply(' ✖ ERROR   ', colors)} ${message}`, ...args);
+        KaiChart.bar(data, paint.colors, options);
     }
-    public warning(message: string, ...args: any[]) {
+
+    public sparkline(values: number[]): void {
+        if (this.silent) return;
         this.stopSpinner();
-        const colors = paint.text.warning;
-        console.log(`${this.getTime()} ${paint.apply(' ⚠ WARNING ', colors)} ${message}`, ...args);
+        KaiChart.sparkline(values, paint.colors);
     }
-    public info(message: string, ...args: any[]) {
+
+    public gauge(value: number, max: number, label?: string): void {
+        if (this.silent) return;
         this.stopSpinner();
-        const colors = paint.text.info;
-        console.log(`${this.getTime()} ${paint.apply(' ℹ INFO    ', colors)} ${message}`, ...args);
+        KaiChart.gauge(value, max, paint.colors, label);
+    }
+
+    // ========== NOTIFICATIONS ==========
+
+    public notify(message: string, title?: string): void {
+        KaiNotify.send({ message, title });
+    }
+
+    public notifySuccess(message: string): void {
+        KaiNotify.success(message);
+    }
+
+    public notifyError(message: string): void {
+        KaiNotify.error(message);
+    }
+
+    // ========== SCREENSHOT ==========
+
+    public startCapture(): void {
+        KaiScreenshot.startCapture();
+    }
+
+    public stopCapture(): string[] {
+        return KaiScreenshot.stopCapture();
+    }
+
+    public saveScreenshot(filename: string): void {
+        KaiScreenshot.save(filename);
+    }
+
+    public saveScreenshotHtml(filename: string): void {
+        KaiScreenshot.saveHtml(filename);
     }
-    public debug(message: string, ...args: any[]) {
+
+    // ========== ENCRYPTION ==========
+
+    public setEncryptionKey(key: string): void {
+        KaiEncrypt.setDefaultKey(key);
+    }
+
+    public encrypted(message: string, key?: string): void {
+        if (this.silent) return;
         this.stopSpinner();
-        const colors = paint.text.debug;
-        console.log(`${this.getTime()} ${paint.apply(' ⚙ DEBUG   ', colors)} ${message}`, ...args);
+        KaiEncrypt.printEncrypted(message, key);
     }
-    public log(message: string) {
+
+    public decrypted(encryptedMessage: string, key?: string): void {
+        if (this.silent) return;
         this.stopSpinner();
-        console.log(`${this.getTime()} ${message}`);
+        KaiEncrypt.printDecrypted(encryptedMessage, key);
     }
-    public box(title: string, message: string) {
+
+    public masked(label: string, value: string, showLast?: number): void {
+        if (this.silent) return;
         this.stopSpinner();
-        const border = paint.apply('─'.repeat(message.length + 4), paint.text.info);
-        console.log(border);
-        console.log(`${paint.apply(`| ${title} |`, paint.text.info)}`);
-        console.log(border);
-        console.log(`| ${message} |`);
-        console.log(border);
+        KaiEncrypt.printMasked(label, value, showLast);
+    }
+
+    // ========== SOUNDS ==========
+
+    public setSoundsDir(dir: string): void {
+        KaiSound.setSoundsDir(dir);
     }
-    public await(message: string) {
-        this.spinner.start(message, paint.text.info[0]);
+
+    public beep(): void {
+        KaiSound.beep();
     }
-    public stop(message?: string) {
-        this.spinner.stop('✔', message, paint.text.success[1]);
+
+    public async soundSuccess(): Promise<void> {
+        await KaiSound.success();
     }
-    private stopSpinner() {
-        // Just ensure no ghost spinner lines if we log something else
-        // this.spinner.stop(); 
-        // Actually we don't want to stop it on every log if it's running, 
-        // but usually logging interrupts the spinner. 
-        // Ideally usage is: start -> wait -> stop/success/fail.
-        // But if user does: start -> info -> stop, the info might break the spinner line.
-        // For now, let's keep it simple.
+
+    public async soundError(): Promise<void> {
+        await KaiSound.error();
+    }
+
+    public async soundWarning(): Promise<void> {
+        await KaiSound.warning();
+    }
+
+    public async soundNotification(): Promise<void> {
+        await KaiSound.notification();
+    }
+
+    public async playSound(filename: string): Promise<void> {
+        await KaiSound.play(filename);
     }
 }
 

package/src/core/Scope.ts

@@ -0,0 +1,35 @@
+import { KaiLogger } from './Logger';
+
+export class ScopedLogger {
+    private parent: KaiLogger;
+    private scopeName: string;
+    constructor(parent: KaiLogger, scopeName: string) {
+        this.parent = parent;
+        this.scopeName = scopeName;
+    }
+    private prefix(message: string): string {
+        return `[${this.scopeName}] ${message}`;
+    }
+    success(message: string, ...args: any[]) {
+        this.parent.success(this.prefix(message), ...args);
+    }
+    error(message: string | Error, ...args: any[]) {
+        if (message instanceof Error) {
+            this.parent.error(message);
+        } else {
+            this.parent.error(this.prefix(message), ...args);
+        }
+    }
+    warning(message: string, ...args: any[]) {
+        this.parent.warning(this.prefix(message), ...args);
+    }
+    info(message: string, ...args: any[]) {
+        this.parent.info(this.prefix(message), ...args);
+    }
+    debug(message: string, ...args: any[]) {
+        this.parent.debug(this.prefix(message), ...args);
+    }
+    log(message: string) {
+        this.parent.log(this.prefix(message));
+    }
+}

package/src/features/Chart.ts

@@ -0,0 +1,81 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+import { paint } from '../styles/palettes';
+
+interface ChartItem {
+    label: string;
+    value: number;
+    color?: string;
+}
+
+export class KaiChart {
+    static bar(data: ChartItem[], theme: any, options?: { width?: number; showValues?: boolean }) {
+        const width = options?.width || 30;
+        const showValues = options?.showValues !== false;
+        
+        const maxValue = Math.max(...data.map(d => d.value));
+        const maxLabelLength = Math.max(...data.map(d => d.label.length));
+
+        console.log('');
+        data.forEach((item, index) => {
+            const percentage = item.value / maxValue;
+            const filledWidth = Math.round(width * percentage);
+            const emptyWidth = width - filledWidth;
+
+            const filled = '█'.repeat(filledWidth);
+            const empty = '░'.repeat(emptyWidth);
+
+            // Cycle through theme colors
+            const colorKeys = ['success', 'info', 'warning', 'error', 'debug'];
+            const colorKey = colorKeys[index % colorKeys.length];
+            // @ts-ignore
+            const colors = theme[colorKey];
+
+            const label = item.label.padEnd(maxLabelLength);
+            // Usamos PaletteEngine apply (que usa KaiChroma)
+            const bar = paint.apply(filled, colors) + KaiChroma.hex('#666666', empty);
+            const value = showValues ? ` ${item.value}` : '';
+
+            console.log(`${KaiChroma.bold(label)} ${bar}${KaiChroma.dim(value)}`);
+        });
+        console.log('');
+    }
+
+    static horizontal(data: ChartItem[], theme: any) {
+        this.bar(data, theme);
+    }
+
+    static sparkline(values: number[], theme: any) {
+        const chars = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+        const min = Math.min(...values);
+        const max = Math.max(...values);
+        const range = max - min || 1;
+
+        const line = values.map(v => {
+            const index = Math.floor(((v - min) / range) * (chars.length - 1));
+            return chars[index];
+        }).join('');
+
+        console.log(paint.apply(line, theme.info));
+    }
+
+    static gauge(value: number, max: number, theme: any, label?: string) {
+        const percentage = Math.min(1, value / max);
+        const width = 20;
+        const filledWidth = Math.round(width * percentage);
+        const emptyWidth = width - filledWidth;
+
+        const filled = '█'.repeat(filledWidth);
+        const empty = '░'.repeat(emptyWidth);
+
+        let colors = theme.success;
+        if (percentage > 0.7) colors = theme.warning;
+        if (percentage > 0.9) colors = theme.error;
+
+        const bar = paint.apply(filled, colors) + KaiChroma.hex('#666666', empty);
+        const percentText = Math.round(percentage * 100) + '%';
+        const labelText = label ? `${label}: ` : '';
+
+        console.log(`${labelText}[${bar}] ${percentText}`);
+    }
+}

package/src/features/Diff.ts

@@ -0,0 +1,25 @@
+
+import { paint } from '../styles/palettes';
+
+export class KaiDiff {
+    static print(before: any, after: any, theme: any, path: string = ''): void {
+        const allKeys = new Set([
+            ...Object.keys(before || {}),
+            ...Object.keys(after || {})
+        ]);
+        allKeys.forEach(key => {
+            const fullPath = path ? `${path}.${key}` : key;
+            const oldVal = before?.[key];
+            const newVal = after?.[key];
+            if (oldVal === undefined && newVal !== undefined) {
+                console.log(paint.apply(`+ ${fullPath}: ${JSON.stringify(newVal)}`, theme.success));
+            } else if (oldVal !== undefined && newVal === undefined) {
+                console.log(paint.apply(`- ${fullPath}: ${JSON.stringify(oldVal)}`, theme.error));
+            } else if (typeof oldVal === 'object' && typeof newVal === 'object' && oldVal !== null && newVal !== null) {
+                KaiDiff.print(oldVal, newVal, theme, fullPath);
+            } else if (oldVal !== newVal) {
+                console.log(paint.apply(`~ ${fullPath}: ${JSON.stringify(oldVal)} → ${JSON.stringify(newVal)}`, theme.warning));
+            }
+        });
+    }
+}