kailogger 1.0.0-dark.red → 1.0.2

package/src/features/Encrypt.ts

@@ -0,0 +1,47 @@
+
+import CryptoJS from 'crypto-js';
+import { KaiChroma } from '../styles/KaiChroma';
+
+export class KaiEncrypt {
+    private static defaultKey: string = 'kailogger-secret-key';
+
+    static setDefaultKey(key: string): void {
+        this.defaultKey = key;
+    }
+
+    static encrypt(message: string, key?: string): string {
+        const secretKey = key || this.defaultKey;
+        return CryptoJS.AES.encrypt(message, secretKey).toString();
+    }
+
+    static decrypt(encrypted: string, key?: string): string {
+        const secretKey = key || this.defaultKey;
+        const bytes = CryptoJS.AES.decrypt(encrypted, secretKey);
+        return bytes.toString(CryptoJS.enc.Utf8);
+    }
+
+    static printEncrypted(message: string, key?: string): void {
+        const encrypted = this.encrypt(message, key);
+        console.log(KaiChroma.hex('#FF00FF', '🔐 [ENCRYPTED] ') + KaiChroma.dim(encrypted));
+    }
+
+    static printDecrypted(encrypted: string, key?: string): void {
+        try {
+            const decrypted = this.decrypt(encrypted, key);
+            console.log(KaiChroma.hex('#00FF00', '🔓 [DECRYPTED] ') + decrypted);
+        } catch (e) {
+            console.log(KaiChroma.hex('#FF0000', '❌ [DECRYPT FAILED] Invalid key or corrupted data'));
+        }
+    }
+
+    static mask(message: string, showLast: number = 4): string {
+        if (message.length <= showLast) return '*'.repeat(message.length);
+        const masked = '*'.repeat(message.length - showLast);
+        const visible = message.slice(-showLast);
+        return masked + visible;
+    }
+
+    static printMasked(label: string, value: string, showLast: number = 4): void {
+        console.log(KaiChroma.hex('#FFFF00', `🔒 ${label}: `) + KaiChroma.dim(this.mask(value, showLast)));
+    }
+}

package/src/features/Notify.ts

@@ -0,0 +1,39 @@
+import notifier from 'node-notifier';
+import * as path from 'path';
+
+export interface NotificationOptions {
+    title?: string;
+    message: string;
+    icon?: string;
+    sound?: boolean;
+    wait?: boolean;
+}
+
+export class KaiNotify {
+    static send(options: NotificationOptions): void {
+        const defaultIcon = path.join(__dirname, '../../src/icon/logo.png'); 
+        let iconPath = options.icon || defaultIcon;
+        if (__filename.includes('dist')) {
+             iconPath = options.icon || path.join(__dirname, '../icon/logo.png');
+        }
+        notifier.notify({
+            title: options.title || 'KaiLogger',
+            message: options.message,
+            icon: iconPath,
+            sound: options.sound !== false,
+            wait: options.wait || false
+        });
+    }
+    static success(message: string): void {
+        this.send({ title: '✅ Success', message, sound: true });
+    }
+    static error(message: string): void {
+        this.send({ title: '❌ Error', message, sound: true });
+    }
+    static warning(message: string): void {
+        this.send({ title: '⚠️ Warning', message, sound: true });
+    }
+    static info(message: string): void {
+        this.send({ title: 'ℹ️ Info', message, sound: false });
+    }
+}

package/src/features/Screenshot.ts

@@ -0,0 +1,70 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { stripAnsi } from '../utils/stripAnsi';
+
+export class KaiScreenshot {
+    private static buffer: string[] = [];
+    private static isRecording: boolean = false;
+    static startCapture(): void {
+        this.buffer = [];
+        this.isRecording = true;
+        const originalLog = console.log;
+        console.log = (...args: any[]) => {
+            if (this.isRecording) {
+                const line = args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ');
+                this.buffer.push(line);
+            }
+            originalLog.apply(console, args);
+        };
+    }
+    static stopCapture(): string[] {
+        this.isRecording = false;
+        return [...this.buffer];
+    }
+    static save(filename: string): void {
+        const dir = path.dirname(filename);
+        if (dir && !fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const cleanLines = this.buffer.map(line => stripAnsi(line));
+        const content = cleanLines.join('\n');
+        fs.writeFileSync(filename, content);
+    }
+    static saveHtml(filename: string): void {
+        const dir = path.dirname(filename);
+        if (dir && !fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const htmlContent = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>KaiLogger Screenshot</title>
+    <style>
+        body {
+            background: #1a1a2e;
+            color: #eee;
+            font-family: 'Consolas', 'Monaco', monospace;
+            padding: 20px;
+            font-size: 14px;
+            line-height: 1.5;
+        }
+        pre {
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+    </style>
+</head>
+<body>
+    <pre>${this.buffer.map(line => stripAnsi(line)).join('\n')}</pre>
+</body>
+</html>`;
+        fs.writeFileSync(filename, htmlContent);
+    }
+    static getBuffer(): string[] {
+        return [...this.buffer];
+    }
+    static clear(): void {
+        this.buffer = [];
+    }
+}

package/src/features/Sound.ts

@@ -0,0 +1,92 @@
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+export class KaiSound {
+    private static soundsDir: string | null = null;
+
+    static setSoundsDir(dir: string): void {
+        this.soundsDir = dir;
+    }
+
+    private static getSoundPath(filename: string): string | null {
+        // 1. Explicitly set directory
+        if (this.soundsDir) {
+            const p = path.join(this.soundsDir, filename);
+            if (fs.existsSync(p)) return p;
+        }
+
+        // 2. Local src/sounds (Development)
+        const srcPath = path.join(__dirname, '../../src/sounds', filename);
+        if (fs.existsSync(srcPath)) return srcPath;
+
+        // 3. Dist sounds (Production/Installed)
+        // __dirname is .../dist/features
+        const distPath = path.join(__dirname, '../sounds', filename);
+        if (fs.existsSync(distPath)) return distPath;
+
+        // 4. Node modules fallback (if imported deeply)
+        try {
+            const pkgPath = require.resolve('kailogger/package.json');
+            const pkgDir = path.dirname(pkgPath);
+            const enrolledPath = path.join(pkgDir, 'dist/sounds', filename);
+            if(fs.existsSync(enrolledPath)) return enrolledPath;
+        } catch (e) {
+            // ignore
+        }
+
+        return null;
+    }
+
+    private static async playFile(filename: string): Promise<void> {
+        const filepath = this.getSoundPath(filename);
+    
+        if (!filepath) {
+            this.beep();
+            return;
+        }
+
+        const { exec } = await import('child_process');
+        const platform = process.platform;
+
+        return new Promise((resolve) => {
+            let command: string;
+
+            if (platform === 'win32') {
+                command = `powershell -c "(New-Object Media.SoundPlayer '${filepath}').PlaySync()"`;
+            } else if (platform === 'darwin') {
+                command = `afplay "${filepath}"`;
+            } else {
+                command = `aplay "${filepath}" 2>/dev/null || paplay "${filepath}" 2>/dev/null`;
+            }
+
+            exec(command, (error) => {
+                resolve();
+            });
+        });
+    }
+
+    static beep(): void {
+        process.stdout.write('\x07');
+    }
+
+    static async success(): Promise<void> {
+        await this.playFile('success.wav');
+    }
+
+    static async error(): Promise<void> {
+        await this.playFile('error.wav');
+    }
+
+    static async warning(): Promise<void> {
+        await this.playFile('warning.wav');
+    }
+
+    static async notification(): Promise<void> {
+        await this.playFile('notification.wav');
+    }
+
+    static async play(filename: string): Promise<void> {
+        await this.playFile(filename);
+    }
+}

package/src/features/Timer.ts

@@ -0,0 +1,35 @@
+
+import { paint } from '../styles/palettes';
+
+export class KaiTimer {
+    private timers: Map<string, number> = new Map();
+    time(label: string): void {
+        this.timers.set(label, performance.now());
+    }
+    timeEnd(label: string, theme: any): number | null {
+        const start = this.timers.get(label);
+        if (!start) {
+            console.log(paint.apply(`⚠ Timer "${label}" does not exist`, theme.warning));
+            return null;
+        }
+        const duration = performance.now() - start;
+        this.timers.delete(label);
+        const ms = duration.toFixed(2);
+        let color = theme.success;
+        let emoji = '⚡';
+
+        if (duration > 1000) {
+            color = theme.warning;
+            emoji = '🐢';
+        }
+        if (duration > 5000) {
+            color = theme.error;
+            emoji = '🔥';
+        }
+        console.log(paint.apply(` ⏱ ${label}: ${ms}ms ${emoji} `, color));
+        return duration;
+    }
+    clear(): void {
+        this.timers.clear();
+    }
+}

package/src/features/Tree.ts

@@ -0,0 +1,25 @@
+
+import { KaiChroma } from '../styles/KaiChroma';
+import { paint } from '../styles/palettes';
+
+interface TreeNode {
+    [key: string]: TreeNode | null;
+}
+export class KaiTree {
+    static print(obj: TreeNode, theme: any, prefix: string = '', isLast: boolean = true): void {
+        const keys = Object.keys(obj);
+        keys.forEach((key, index) => {
+            const isLastItem = index === keys.length - 1;
+            const connector = isLastItem ? '└── ' : '├── ';
+            const value = obj[key];
+            const line = prefix + connector; // connector + key part
+            if (value === null) {
+                console.log(KaiChroma.hex(theme.dim, prefix + connector) + paint.apply(key, theme.info));
+            } else {
+                console.log(KaiChroma.hex(theme.dim, prefix + connector) + paint.apply(key + '/', theme.success));
+                const newPrefix = prefix + (isLastItem ? '    ' : '│   ');
+                KaiTree.print(value, theme, newPrefix, isLastItem);
+            }
+        });
+    }
+}

package/src/features/index.ts

@@ -0,0 +1,8 @@
+export * from './Timer';
+export * from './Tree';
+export * from './Diff';
+export * from './Chart';
+export * from './Notify';
+export * from './Screenshot';
+export * from './Encrypt';
+export * from './Sound';

package/src/index.ts

@@ -1,3 +1,15 @@
 export * from './core/Logger';
+export * from './core/Config';
+export * from './core/Scope';
 export * from './styles/palettes';
-export * from './styles/gradients';
+export * from './styles/KaiChroma';
+export * from './types';
+export * from './transports';
+export * from './features';
+export { KaiSpinner } from './utils/spinner';
+export { KaiProgress } from './utils/progress';
+export { KaiTable } from './utils/table';
+export { KaiJson } from './utils/json';
+export { KaiPrompt } from './utils/prompt';
+export { KaiSelection } from './utils/selection';
+export { PrettyError } from './utils/prettyError';