kailogger 1.0.0-dark.red → 1.0.2

package/src/transports/WebhookTransport.ts

@@ -0,0 +1,37 @@
+import { LogLevel, Transport } from '../types';
+import { stripAnsi } from '../utils/stripAnsi';
+
+export interface WebhookTransportOptions {
+    url: string;
+    method?: 'POST' | 'PUT';
+    headers?: Record<string, string>;
+    minLevel?: LogLevel;
+}
+export class WebhookTransport implements Transport {
+    name = 'webhook';
+    private url: string;
+    private method: 'POST' | 'PUT';
+    private headers: Record<string, string>;
+    constructor(options: WebhookTransportOptions) {
+        this.url = options.url;
+        this.method = options.method || 'POST';
+        this.headers = options.headers || { 'Content-Type': 'application/json' };
+    }
+    async log(level: LogLevel, message: string, meta?: any): Promise<void> {
+        try {
+            const payload = {
+                timestamp: new Date().toISOString(),
+                level: level.toUpperCase(),
+                message: stripAnsi(message),
+                meta
+            };
+            await fetch(this.url, {
+                method: this.method,
+                headers: this.headers,
+                body: JSON.stringify(payload)
+            });
+        } catch (e) {
+            console.error('[KaiLogger] Webhook transport failed:', e);
+        }
+    }
+}

package/src/transports/index.ts

@@ -0,0 +1,3 @@
+export * from './ConsoleTransport';
+export * from './FileTransport';
+export * from './WebhookTransport';

package/src/types/cli-highlight.d.ts

@@ -0,0 +1,3 @@
+declare module 'cli-highlight' {
+    export function highlight(code: string, options?: any): string;
+}

package/src/types/index.ts

@@ -0,0 +1,23 @@
+export type LogLevel = 'debug' | 'info' | 'success' | 'warning' | 'error' | 'silent';
+export const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+    debug: 0,
+    info: 1,
+    success: 2,
+    warning: 3,
+    error: 4,
+    silent: 5
+};
+export interface KaiConfig {
+    theme?: string;
+    level?: LogLevel;
+    timestamp?: 'ISO' | 'locale' | 'relative' | 'none';
+    silent?: boolean;
+    transports?: Transport[];
+}
+export interface Transport {
+    name: string;
+    log(level: LogLevel, message: string, meta?: any): void | Promise<void>;
+}
+export interface Formatter {
+    format(level: LogLevel, message: string, timestamp: string, scope?: string): string;
+}

package/src/utils/json.ts

@@ -0,0 +1,33 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+
+export class KaiJson {
+    static print(obj: any, theme: any) {
+        const jsonStr = JSON.stringify(obj, null, 2);
+        
+        // Manual colorization for full control using KaiChroma
+        const colored = jsonStr
+            // Strings (keys)
+            .replace(/"([^"]+)":/g, (match, key) => {
+                return KaiChroma.hex(theme.info[0], `"${key}"`) + ':';
+            })
+            // String values
+            .replace(/: "([^"]*)"/g, (match, val) => {
+                return ': ' + KaiChroma.hex(theme.success[1], `"${val}"`);
+            })
+            // Numbers
+            .replace(/: (\d+\.?\d*)/g, (match, num) => {
+                return ': ' + KaiChroma.hex(theme.warning[0], num);
+            })
+            // Booleans
+            .replace(/: (true|false)/g, (match, bool) => {
+                return ': ' + KaiChroma.hex(theme.error[0], bool);
+            })
+            // Null
+            .replace(/: (null)/g, (match, n) => {
+                return ': ' + KaiChroma.hex(theme.dim, n);
+            });
+
+        console.log(colored);
+    }
+}

package/src/utils/prettyError.ts

@@ -0,0 +1,65 @@
+
+import * as stackTrace from 'stack-trace';
+import * as fs from 'fs';
+import { KaiChroma } from '../styles/KaiChroma';
+import { paint } from '../styles/palettes';
+
+export class PrettyError {
+    static handle(error: Error, theme: any) {
+        const trace = stackTrace.parse(error);
+        
+        console.log('');
+        console.log(paint.apply(` 💥 ${error.name} `, theme.error));
+        console.log(KaiChroma.bold(error.message));
+        
+        // Find the first relevant frame (not node internal)
+        const frame = trace.find(t => {
+            const file = t.getFileName();
+            return file && !file.includes('node_modules') && !file.startsWith('node:');
+        });
+
+        if (frame) {
+            const fileName = frame.getFileName();
+            const lineNumber = frame.getLineNumber();
+            
+            console.log(KaiChroma.hex('#666666', `at ${fileName}:${lineNumber}`));
+            console.log(KaiChroma.hex('#666666', '─'.repeat(50)));
+
+            try {
+                const content = fs.readFileSync(fileName, 'utf-8');
+                const lines = content.split('\n');
+                const start = Math.max(0, lineNumber - 3);
+                const end = Math.min(lines.length, lineNumber + 2);
+
+                for (let i = start; i < end; i++) {
+                    const isErrorLine = i + 1 === lineNumber;
+                    const lineNumStr = (i + 1).toString().padEnd(4);
+                    
+                    if (isErrorLine) {
+                        const lineContent = KaiChroma.bold(lines[i]);
+                        console.log(paint.apply(` > ${lineNumStr} | ${lineContent}`, theme.error));
+                    } else {
+                        console.log(KaiChroma.hex('#888888', `   ${lineNumStr} | ${lines[i]}`));
+                    }
+                }
+            } catch (e) {
+                // Fallback if file cannot be read
+                console.log(KaiChroma.dim('   (Source code unavailable)'));
+            }
+            console.log(KaiChroma.hex('#666666', '─'.repeat(50)));
+        }
+
+        // Show simplified stack
+        console.log('');
+        console.log(KaiChroma.dim('Stack Trace:'));
+        trace.forEach(t => {
+            const fn = t.getFunctionName() || '<anonymous>';
+            const file = t.getFileName();
+            const line = t.getLineNumber();
+            if (file && !file.includes('node_modules')) {
+                 console.log(KaiChroma.dim(`  at ${fn} (${file}:${line})`));
+            }
+        });
+        console.log('');
+    }
+}

package/src/utils/progress.ts

@@ -0,0 +1,56 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+import { palettes, ThemeName } from '../styles/palettes';
+
+export class KaiProgress {
+    private total: number;
+    private current: number;
+    private width: number;
+    private theme: ThemeName;
+
+    constructor(total: number, width: number = 40, theme: ThemeName = 'zen') {
+        this.total = total;
+        this.current = 0;
+        this.width = width;
+        this.theme = theme;
+    }
+
+    public update(current: number) {
+        this.current = current;
+        this.render();
+    }
+
+    public increment(amount: number = 1) {
+        this.current = Math.min(this.total, this.current + amount);
+        this.render();
+    }
+
+    private render() {
+        const percentage = Math.min(1, this.current / this.total);
+        const filledWidth = Math.round(this.width * percentage);
+        const emptyWidth = this.width - filledWidth;
+        
+        const filledChar = '█';
+        const emptyChar = '░';
+
+        const filled = filledChar.repeat(filledWidth);
+        const empty = emptyChar.repeat(emptyWidth);
+        
+        const palette = palettes[this.theme];
+        const colors = palette.info;
+        const dimColor = palette.dim;
+
+        // Utilizamos KaiChroma.gradient en lugar de gradient-string
+        const barFilled = KaiChroma.gradient(colors, filled);
+        const barEmpty = KaiChroma.hex(dimColor, empty);
+        const bar = barFilled + barEmpty;
+        
+        const percentText = Math.round(percentage * 100).toString().padStart(3);
+        
+        process.stdout.write(`\r${bar} ${percentText}%`);
+        
+        if (this.current >= this.total) {
+            process.stdout.write('\n');
+        }
+    }
+}

package/src/utils/prompt.ts

@@ -0,0 +1,27 @@
+
+import * as readline from 'readline';
+import { paint } from '../styles/palettes';
+
+export class KaiPrompt {
+    static ask(question: string, theme: any): Promise<string> {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        const q = paint.apply(`? ${question} `, theme.info);
+
+        return new Promise(resolve => {
+            rl.question(q, (answer) => {
+                rl.close();
+                resolve(answer);
+            });
+        });
+    }
+
+    static confirm(question: string, theme: any): Promise<boolean> {
+        return this.ask(`${question} (y/n)`, theme).then(ans => {
+            return ans.toLowerCase().startsWith('y');
+        });
+    }
+}

package/src/utils/selection.ts

@@ -0,0 +1,136 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+import { paint } from '../styles/palettes';
+import * as readline from 'readline';
+
+export class KaiSelection {
+    static async select(question: string, options: string[], theme: any): Promise<string> {
+        return new Promise((resolve) => {
+            let selectedIndex = 0;
+            const stdin = process.stdin;
+            const stdout = process.stdout;
+
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.setEncoding('utf8');
+
+            const render = () => {
+                readline.moveCursor(stdout, 0, -(options.length + 1));
+                readline.clearScreenDown(stdout);
+
+                const q = paint.apply(`? ${question} `, theme.info);
+                console.log(q);
+
+                options.forEach((opt, i) => {
+                    if (i === selectedIndex) {
+                        const pointer = paint.apply('>', theme.success);
+                        const text = paint.apply(opt, theme.success);
+                        console.log(`${pointer} ${text}`);
+                    } else {
+                        console.log(`  ${opt}`);
+                    }
+                });
+            };
+
+            console.log('\n'.repeat(options.length));
+            render();
+
+            const handler = (key: string) => {
+                if (key === '\u0003') { // Ctrl+C
+                    process.exit();
+                }
+
+                if (key === '\u001b[A') { // Up arrow
+                    selectedIndex = (selectedIndex > 0) ? selectedIndex - 1 : options.length - 1;
+                    render();
+                } else if (key === '\u001b[B') { // Down arrow
+                    selectedIndex = (selectedIndex < options.length - 1) ? selectedIndex + 1 : 0;
+                    render();
+                } else if (key === '\r') { // Enter
+                    stdin.removeListener('data', handler);
+                    stdin.setRawMode(false);
+                    stdin.pause();
+                    
+                    readline.moveCursor(stdout, 0, -(options.length + 1));
+                    readline.clearScreenDown(stdout);
+                    console.log(`${paint.apply(`✔ ${question}`, theme.success)} ${KaiChroma.bold(options[selectedIndex])}`);
+                    
+                    resolve(options[selectedIndex]);
+                }
+            };
+
+            stdin.on('data', handler);
+        });
+    }
+
+    static async multiselect(question: string, options: string[], theme: any): Promise<string[]> {
+        return new Promise((resolve) => {
+            let selectedIndex = 0;
+            const selected = new Set<number>();
+            const stdin = process.stdin;
+            const stdout = process.stdout;
+
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.setEncoding('utf8');
+
+            const render = () => {
+                readline.moveCursor(stdout, 0, -(options.length + 1));
+                readline.clearScreenDown(stdout);
+
+                const q = paint.apply(`? ${question} `, theme.info);
+                console.log(`${q} ${KaiChroma.dim('(Space to select, Enter to confirm)')}`);
+
+                options.forEach((opt, i) => {
+                    const isSelected = selected.has(i);
+                    const isHovered = i === selectedIndex;
+                    
+                    let prefix = isSelected ? paint.apply('◉', theme.success) : '◯';
+                    let text = opt;
+
+                    if (isHovered) {
+                         prefix = paint.apply('>', theme.info) + ' ' + prefix;
+                         text = paint.apply(text, theme.info);
+                    } else {
+                        prefix = '  ' + prefix;
+                    }
+
+                    console.log(`${prefix} ${text}`);
+                });
+            };
+
+            console.log('\n'.repeat(options.length));
+            render();
+
+            const handler = (key: string) => {
+                if (key === '\u0003') process.exit();
+
+                if (key === '\u001b[A') { // Up
+                    selectedIndex = (selectedIndex > 0) ? selectedIndex - 1 : options.length - 1;
+                    render();
+                } else if (key === '\u001b[B') { // Down
+                    selectedIndex = (selectedIndex < options.length - 1) ? selectedIndex + 1 : 0;
+                    render();
+                } else if (key === ' ') { // Space
+                    if (selected.has(selectedIndex)) selected.delete(selectedIndex);
+                    else selected.add(selectedIndex);
+                    render();
+                } else if (key === '\r') { // Enter
+                    stdin.removeListener('data', handler);
+                    stdin.setRawMode(false);
+                    stdin.pause();
+                    
+                    readline.moveCursor(stdout, 0, -(options.length + 1));
+                    readline.clearScreenDown(stdout);
+                    
+                    const result = options.filter((_, i) => selected.has(i));
+                    console.log(`${paint.apply(`✔ ${question}`, theme.success)} ${KaiChroma.bold(result.join(', '))}`);
+                    
+                    resolve(result);
+                }
+            };
+
+            stdin.on('data', handler);
+        });
+    }
+}

package/src/utils/spinner.ts

@@ -1,22 +1,25 @@
-import process from 'process';
-import chalk from 'chalk';
+
+import { KaiChroma } from '../styles/KaiChroma';
 
 const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
 export class KaiSpinner {
     private timer: NodeJS.Timeout | null = null;
     private index = 0;
     private text = '';
-    private colorFn = chalk.cyan;
+    private colorHex = '#00FFFF'; // Default cyan-ish
+
     start(text: string, colorHex: string = '#00FFFF') {
         this.stop();
         this.text = text;
-        this.colorFn = chalk.hex(colorHex);
+        this.colorHex = colorHex;
         process.stdout.write('\x1B[?25l');
         this.timer = setInterval(() => {
             const frame = frames[this.index = ++this.index % frames.length];
-            process.stdout.write(`\r${this.colorFn(frame)} ${this.text}`);
+            process.stdout.write(`\r${KaiChroma.hex(this.colorHex, frame)} ${this.text}`);
         }, 80);
     }
+
     stop(symbol: string = '✔', endText?: string, colorHex?: string) {
         if (this.timer) {
             clearInterval(this.timer);
@@ -24,11 +27,12 @@ export class KaiSpinner {
             process.stdout.write('\r\x1B[K');
             process.stdout.write('\x1B[?25h');
             if (endText) {
-                const finalColor = colorHex ? chalk.hex(colorHex) : this.colorFn;
-                console.log(`${finalColor(symbol)} ${endText}`);
+                const finalColor = colorHex || this.colorHex;
+                console.log(`${KaiChroma.hex(finalColor, symbol)} ${endText}`);
             }
         }
     }
+
     fail(text: string) {
         this.stop('✖', text, '#FF0000');
     }

package/src/utils/stripAnsi.ts

@@ -0,0 +1,6 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+
+export function stripAnsi(str: string): string {
+    return KaiChroma.strip(str);
+}

package/src/utils/table.ts

@@ -0,0 +1,38 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+import { paint } from '../styles/palettes';
+
+export class KaiTable {
+    static print(data: any[], theme: any) {
+        if (data.length === 0) return;
+
+        const keys = Object.keys(data[0]);
+        const colWidths = keys.map(key => {
+            const maxValLen = Math.max(...data.map(row => String(row[key]).length));
+            return Math.max(key.length, maxValLen) + 2;
+        });
+
+        const createRow = (rowItems: string[], isHeader = false) => {
+            return rowItems.map((item, i) => {
+                const cell = item.padEnd(colWidths[i]);
+                return isHeader 
+                    ? paint.apply(cell, theme.info)
+                    : cell;
+            }).join(' │ ');
+        };
+
+        const separator = colWidths.map(w => '─'.repeat(w)).join('─┼─');
+        const dimColor = (text: string) => KaiChroma.hex(theme.dim, text);
+        
+        console.log(dimColor(separator));
+        console.log(createRow(keys, true));
+        console.log(dimColor(separator));
+        
+        data.forEach(row => {
+            const values = keys.map(k => String(row[k]));
+            console.log(createRow(values));
+        });
+        
+        console.log(dimColor(separator));
+    }
+}

package/src/styles/gradients.ts

@@ -1,22 +0,0 @@
-import gradient from 'gradient-string';
-import { palettes, ThemeName } from './palettes';
-
-export class GradientEngine {
-    private currentTheme: ThemeName = 'zen';
-    setTheme(theme: ThemeName) {
-        if (palettes[theme]) {
-            this.currentTheme = theme;
-        }
-    }
-    get text() {
-        return palettes[this.currentTheme];
-    }
-    apply(text: string, colors: string[]) {
-        return gradient(colors)(text);
-    }
-    multiline(text: string, colors: string[]) {
-        return gradient(colors).multiline(text);
-    }
-}
-
-export const paint = new GradientEngine();