kailogger 1.0.1-dark.red → 1.0.2

package/src/utils/prettyError.ts

@@ -1,50 +1,63 @@
-import chalk from 'chalk';
+
 import * as stackTrace from 'stack-trace';
 import * as fs from 'fs';
-import { paint } from '../styles/gradients';
+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(chalk.bold(error.message));
-        console.log('');
+        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(chalk.gray(`at ${fileName}:${lineNumber}`));
-            console.log(chalk.gray('─'.repeat(50)));
+            
+            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 = chalk.bold(lines[i]);
+                        const lineContent = KaiChroma.bold(lines[i]);
                         console.log(paint.apply(` > ${lineNumStr} | ${lineContent}`, theme.error));
                     } else {
-                        console.log(chalk.gray(`   ${lineNumStr} | ${lines[i]}`));
+                        console.log(KaiChroma.hex('#888888', `   ${lineNumStr} | ${lines[i]}`));
                     }
                 }
             } catch (e) {
-                console.log(chalk.dim('   (Source code unavailable)'));
+                // Fallback if file cannot be read
+                console.log(KaiChroma.dim('   (Source code unavailable)'));
             }
-            console.log(chalk.gray('─'.repeat(50)));
+            console.log(KaiChroma.hex('#666666', '─'.repeat(50)));
         }
+
+        // Show simplified stack
         console.log('');
-        console.log(chalk.dim('Stack Trace:'));
+        console.log(KaiChroma.dim('Stack Trace:'));
         trace.forEach(t => {
+            const fn = t.getFunctionName() || '<anonymous>';
             const file = t.getFileName();
-            if (file && !file.includes('node_modules') && !file.startsWith('node:')) {
-                console.log(chalk.dim(`   at ${t.getFunctionName() || '<anonymous>'} (${file}:${t.getLineNumber()})`));
+            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

@@ -1,4 +1,5 @@
-import gradient from 'gradient-string';
+
+import { KaiChroma } from '../styles/KaiChroma';
 import { palettes, ThemeName } from '../styles/palettes';
 
 export class KaiProgress {
@@ -6,35 +7,48 @@ export class KaiProgress {
     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 emptyWidth = this.width - filledWidth;
+        
         const filledChar = '█';
         const emptyChar = '░';
+
         const filled = filledChar.repeat(filledWidth);
         const empty = emptyChar.repeat(emptyWidth);
-        const palette = palettes[this.theme] as any;
+        
+        const palette = palettes[this.theme];
         const colors = palette.info;
         const dimColor = palette.dim;
-        const grad = gradient(colors);
-        const bar = grad(filled) + gradient([dimColor, dimColor])(empty);
+
+        // 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

@@ -1,5 +1,6 @@
+
 import * as readline from 'readline';
-import { paint } from '../styles/gradients';
+import { paint } from '../styles/palettes';
 
 export class KaiPrompt {
     static ask(question: string, theme: any): Promise<string> {
@@ -7,14 +8,17 @@ export class KaiPrompt {
             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.trim());
+                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

@@ -1,6 +1,7 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+import { paint } from '../styles/palettes';
 import * as readline from 'readline';
-import chalk from 'chalk';
-import { paint } from '../styles/gradients';
 
 export class KaiSelection {
     static async select(question: string, options: string[], theme: any): Promise<string> {
@@ -8,43 +9,52 @@ export class KaiSelection {
             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}`);
+                        console.log(`${pointer} ${text}`);
                     } else {
-                        console.log(chalk.gray(`   ${opt}`));
+                        console.log(`  ${opt}`);
                     }
                 });
             };
+
             console.log('\n'.repeat(options.length));
             render();
+
             const handler = (key: string) => {
-                if (key === '\u0003') { 
+                if (key === '\u0003') { // Ctrl+C
                     process.exit();
                 }
-                if (key === '\u001b[A') { 
+
+                if (key === '\u001b[A') { // Up arrow
                     selectedIndex = (selectedIndex > 0) ? selectedIndex - 1 : options.length - 1;
                     render();
-                } else if (key === '\u001b[B') {
+                } else if (key === '\u001b[B') { // Down arrow
                     selectedIndex = (selectedIndex < options.length - 1) ? selectedIndex + 1 : 0;
                     render();
-                } else if (key === '\r') {
+                } 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)} ${chalk.bold(options[selectedIndex])}`);
+                    console.log(`${paint.apply(`✔ ${question}`, theme.success)} ${KaiChroma.bold(options[selectedIndex])}`);
+                    
                     resolve(options[selectedIndex]);
                 }
             };
@@ -52,61 +62,74 @@ export class KaiSelection {
             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} ${chalk.dim('(Space to select, Enter to confirm)')}`);
+                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;
-                        text = chalk.gray(text);
                     }
-                    
+
                     console.log(`${prefix} ${text}`);
                 });
             };
+
             console.log('\n'.repeat(options.length));
             render();
+
             const handler = (key: string) => {
                 if (key === '\u0003') process.exit();
-                if (key === '\u001b[A') { 
+
+                if (key === '\u001b[A') { // Up
                     selectedIndex = (selectedIndex > 0) ? selectedIndex - 1 : options.length - 1;
                     render();
-                } else if (key === '\u001b[B') {
+                } else if (key === '\u001b[B') { // Down
                     selectedIndex = (selectedIndex < options.length - 1) ? selectedIndex + 1 : 0;
                     render();
-                } else if (key === ' ') { 
+                } else if (key === ' ') { // Space
                     if (selected.has(selectedIndex)) selected.delete(selectedIndex);
                     else selected.add(selectedIndex);
                     render();
-                } else if (key === '\r') { 
+                } 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)} ${chalk.bold(result.join(', '))}`);
+                    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

@@ -1,3 +1,6 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+
 export function stripAnsi(str: string): string {
-    return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+    return KaiChroma.strip(str);
 }

package/src/utils/table.ts

@@ -1,14 +1,17 @@
-import chalk from 'chalk';
-import { paint } from '../styles/gradients';
+
+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]);
@@ -17,15 +20,19 @@ export class KaiTable {
                     : cell;
             }).join(' │ ');
         };
+
         const separator = colWidths.map(w => '─'.repeat(w)).join('─┼─');
-        const dimColor = chalk.hex(theme.dim);
+        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();