kailogger 1.0.0-dark.red → 1.0.1-dark.red

package/README.md

@@ -1,19 +1,31 @@
-# 🌸 KaiLogger
+# KaiLogger
 
-> The most **divine**, **beautiful**, and **elegant** logger for Node.js. 
-> Experience logging like never before with mesmerizing gradients, smooth animations, and a developer experience that feels like Zen.
+> **The Ultimate Logger for Node.js** — Beautiful, powerful, and designed for developers who care about aesthetics.
 
-![KaiLogger](https://img.shields.io/npm/v/kailogger?style=for-the-badge&color=ff69b4)
-![TypeScript](https://img.shields.io/badge/Written%20In-TypeScript-blue?style=for-the-badge)
-![License](https://img.shields.io/npm/l/kailogger?style=for-the-badge&color=green)
+<p align="center">
+  <img src="https://files.catbox.moe/et33ah.png" alt="KaiLogger Logo" width="600" />
+</p>
+
+![Version](https://img.shields.io/badge/version-1.0.1-blue)
+![TypeScript](https://img.shields.io/badge/TypeScript-Ready-3178C6)
+
+Turn your boring console logs into a cyber-aesthetic experience. KaiLogger isn't just a logger; it's a complete CLI toolkit.
+
+---
 
 ## Features
 
-- » **Divine Gradients**: Make your logs pop with stunning, automatically applied color gradients.
-- » **Beautiful Themes**: Switch between `Zen` (Nature), `Neon` (Cyberpunk), and `Pastel` (Soft) modes.
-- » **Smooth Animations**: Built-in loading spinners that just work.
-- » **High Performance**: Minimal overhead, maximum beauty.
-- » **TypeScript Native**: Fully typed for a superior developer experience.
+| Category        | Features                                                    |
+| --------------- | ----------------------------------------------------------- |
+| **Logging**     | Log levels, scoped loggers, custom badges, silent mode      |
+| **Styling**     | 6 built-in themes, gradients, pretty boxes                  |
+| **Interactive** | Spinners, progress bars, select menus, prompts              |
+| **Debug**       | Pretty errors, JSON highlighting, diff view, tree view      |
+| **Visuals**     | **Charts** (Bar, Sparkline, Gauge), **Screenshots**         |
+| **System**      | **Desktop Notifications**, **Encryption**, **Sound Alerts** |
+| **Transports**  | Console, File (with rotation), Webhooks                     |
+
+---
 
 ## Installation
 
@@ -21,66 +33,184 @@
 npm install kailogger
 ```
 
-## Usage
+---
+
+## Quick Start
+
+```typescript
+import { kai } from "kailogger";
+
+kai.success("Hello, beautiful world!");
+kai.error("Something went wrong");
+kai.warning("Careful there");
+kai.info("Just FYI");
+kai.debug("For your eyes only");
+```
+
+---
+
+## Charts (v1.1)
+
+Visualize data directly in your terminal.
+
+### Bar Chart
+
+```typescript
+kai.chart([
+  { label: "Users", value: 1500 },
+  { label: "Sales", value: 890 },
+  { label: "Errors", value: 32 },
+]);
+```
+
+### Sparkline
+
+```typescript
+kai.sparkline([10, 25, 40, 35, 60, 90, 45, 20]);
+// Output: ▂▃▄▃▅▇▄▂
+```
+
+### Gauge
+
+```typescript
+kai.gauge(75, 100, "CPU");
+// CPU: [███████████████░░░░░] 75%
+```
+
+---
+
+## Notifications & Sounds (v1.1)
+
+### Desktop Notifications
+
+Send native system notifications.
+
+```typescript
+kai.notify("Build complete!", "✅ Success");
+```
+
+### Sound Alerts
+
+Play sounds for events. (Requires `src/sounds` folder or system sounds)
+
+```typescript
+// Configure sounds directory (optional)
+kai.setSoundsDir("./src/sounds");
+
+await kai.soundSuccess();
+await kai.soundError();
+kai.beep();
+```
+
+---
+
+## Encryption (v1.1)
+
+Handle sensitive data securely.
+
+```typescript
+// Mask sensitive info in logs
+kai.masked("API Key", "sk-1234567890abcdef", 4);
+// 🔒 API Key: ************cdef
+
+// Encrypt/Decrypt helpers
+const secret = kai.encrypted("My Secret Data", "my-key");
+kai.decrypted(secret, "my-key");
+```
+
+---
+
+## Screen Capture (v1.1)
 
-Using KaiLogger is as simple as breathing.
+Capture terminal output to file.
 
 ```typescript
-import { kai } from 'kailogger';
-
-// 🌿 Standard Logging
-kai.success('Database connected successfully');
-kai.info('Server started on port 3000');
-kai.warning('Memory usage is slightly elevated');
-kai.error('Connection to Redis failed');
-kai.debug('User payload received');
-
-// 🌀 Loading Animations
-kai.await('Connecting to the quantum realm...');
-
-setTimeout(() => {
-  kai.stop('Connection established!'); 
-  // or kai.stop() to just clear the spinner
-}, 2000);
+kai.startCapture();
+
+kai.success("This will be captured");
+kai.info("So will this");
+
+kai.saveScreenshot("logs/session.txt");
+kai.saveScreenshotHtml("logs/session.html"); // Saves as styled HTML!
 ```
 
+---
+
 ## Themes
 
-Match your mood or your terminal's aesthetic.
+```typescript
+kai.setTheme("neon");
+// Options: 'zen', 'neon', 'pastel', 'hacker', 'sunset', 'ocean'
+```
+
+---
+
+## Log Levels & Scopes
 
-### **Zen Mode** (Default)
-Calming greens, blues, and nature-inspired gradients.
 ```typescript
-kai.setTheme('zen');
-kai.info('Nature is efficient.');
+// Set global level
+kai.setLevel("warning");
+
+// Scoped Logger
+const db = kai.scope("Database");
+db.info("Connected"); // [Database] Connected
 ```
 
-### **Neon Mode**
-High-contrast, cyberpunk-inspired bright colors.
+---
+
+## Performance Timer
+
 ```typescript
-kai.setTheme('neon');
-kai.info('System override active.');
+kai.time("query");
+await db.query();
+kai.timeEnd("query");
+// ⏱ query: 145.32ms ⚡
 ```
 
-### **Pastel Mode**
-Soft, easy-on-the-eyes colors for a gentle experience.
+---
+
+## Tree & Diff View
+
 ```typescript
-kai.setTheme('pastel');
-kai.info('Soft cloud computing.');
+// Tree View
+kai.tree({
+  src: { "index.ts": null, utils: { "helper.ts": null } },
+});
+
+// Diff View
+kai.diff({ status: "idle" }, { status: "active" });
 ```
 
-## API Reference
+---
+
+## Interactive Prompts
 
-- » `kai.success(msg)`: Log a success message.
-- » `kai.error(msg)`: Log an error message.
-- » `kai.warning(msg)`: Log a warning.
-- » `kai.info(msg)`: Log an info message.
-- » `kai.debug(msg)`: Log a debug message.
-- » `kai.log(msg)`: detailed log without level badge.
-- » `kai.box(title, msg)`: Print a message inside a beautiful box.
-- » `kai.await(msg)`: Start a loading spinner.
-- » `kai.stop(msg?)`: Stop the spinner (optional: replace with a success message).
+```typescript
+const name = await kai.ask("Name?");
+const framework = await kai.select("Framework", ["React", "Vue", "Svelte"]);
+```
+
+---
+
+## Transports
+
+```typescript
+kai.addFileTransport({
+  filename: "./logs/app.log",
+  maxSize: 10 * 1024 * 1024,
+});
+
+kai.addWebhookTransport({
+  url: "https://webhook.site/...",
+});
+```
+
+---
 
 ## License
 
-MIT © Soblend
+ISC
+
+---
+
+**By Soblend Development Studio**

package/dist/core/Config.d.ts

@@ -0,0 +1,15 @@
+import { KaiConfig, Transport } from '../types';
+declare class ConfigManager {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): ConfigManager;
+    configure(options: Partial<KaiConfig>): void;
+    get<K extends keyof KaiConfig>(key: K): KaiConfig[K];
+    getAll(): KaiConfig;
+    reset(): void;
+    addTransport(transport: Transport): void;
+    removeTransport(name: string): void;
+}
+export declare const config: ConfigManager;
+export {};

package/dist/core/Config.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const DEFAULT_CONFIG = {
+    theme: 'zen',
+    level: 'debug',
+    timestamp: 'locale',
+    silent: false,
+    transports: []
+};
+class ConfigManager {
+    constructor() {
+        this.config = { ...DEFAULT_CONFIG };
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    configure(options) {
+        this.config = { ...this.config, ...options };
+    }
+    get(key) {
+        return this.config[key];
+    }
+    getAll() {
+        return { ...this.config };
+    }
+    reset() {
+        this.config = { ...DEFAULT_CONFIG };
+    }
+    addTransport(transport) {
+        if (!this.config.transports)
+            this.config.transports = [];
+        this.config.transports.push(transport);
+    }
+    removeTransport(name) {
+        if (this.config.transports) {
+            this.config.transports = this.config.transports.filter(t => t.name !== name);
+        }
+    }
+}
+exports.config = ConfigManager.getInstance();

package/dist/core/Logger.d.ts

@@ -1,20 +1,91 @@
+import { KaiProgress } from '../utils/progress';
 import { ThemeName } from '../styles/palettes';
+import { ScopedLogger } from './Scope';
+import { LogLevel } from '../types';
+import { FileTransportOptions } from '../transports/FileTransport';
+import { WebhookTransportOptions } from '../transports/WebhookTransport';
+interface LoggerOptions {
+    theme?: ThemeName;
+    level?: LogLevel;
+    logFile?: string;
+    silent?: boolean;
+    timestamp?: 'ISO' | 'locale' | 'relative' | 'none';
+}
 export declare class KaiLogger {
-    theme: ThemeName;
     private spinner;
-    constructor(theme?: ThemeName);
+    private timer;
+    private logFilePath?;
+    private buffer;
+    private startTime;
+    theme: ThemeName;
+    level: LogLevel;
+    silent: boolean;
+    timestampFormat: 'ISO' | 'locale' | 'relative' | 'none';
+    constructor(options?: LoggerOptions | ThemeName);
+    configure(options: Partial<LoggerOptions>): void;
     setTheme(theme: ThemeName): void;
+    setLevel(level: LogLevel): void;
+    setSilent(silent: boolean): void;
+    addFileTransport(options: FileTransportOptions): void;
+    addWebhookTransport(options: WebhookTransportOptions): void;
+    removeTransport(name: string): void;
+    scope(name: string): ScopedLogger;
     private getTime;
-    private format;
+    private shouldLog;
+    private logToFile;
+    private addToBuffer;
+    getBuffer(): string[];
+    clearBuffer(): void;
+    private print;
     success(message: string, ...args: any[]): void;
-    error(message: string, ...args: any[]): void;
+    error(message: string | Error, ...args: any[]): void;
     warning(message: string, ...args: any[]): void;
     info(message: string, ...args: any[]): void;
     debug(message: string, ...args: any[]): void;
     log(message: string): void;
+    custom(badge: string, color: string, message: string, ...args: any[]): void;
     box(title: string, message: string): void;
     await(message: string): void;
     stop(message?: string): void;
     private stopSpinner;
+    createProgress(total: number, width?: number): KaiProgress;
+    table(data: any[]): void;
+    json(data: any): void;
+    tree(data: any): void;
+    diff(before: any, after: any): void;
+    time(label: string): void;
+    timeEnd(label: string): number | null;
+    ask(question: string): Promise<string>;
+    confirm(question: string): Promise<boolean>;
+    select(question: string, options: string[]): Promise<string>;
+    multiselect(question: string, options: string[]): Promise<string[]>;
+    chart(data: {
+        label: string;
+        value: number;
+    }[], options?: {
+        width?: number;
+        showValues?: boolean;
+    }): void;
+    sparkline(values: number[]): void;
+    gauge(value: number, max: number, label?: string): void;
+    notify(message: string, title?: string): void;
+    notifySuccess(message: string): void;
+    notifyError(message: string): void;
+    startCapture(): void;
+    stopCapture(): string[];
+    saveScreenshot(filename: string): void;
+    saveScreenshotHtml(filename: string): void;
+    setEncryptionKey(key: string): void;
+    encrypted(message: string, key?: string): void;
+    decrypted(encryptedMessage: string, key?: string): void;
+    masked(label: string, value: string, showLast?: number): void;
+    setSoundsDir(dir: string): void;
+    beep(): void;
+    soundSuccess(): Promise<void>;
+    soundError(): Promise<void>;
+    soundWarning(): Promise<void>;
+    soundNotification(): Promise<void>;
+    playSound(filename: string): Promise<void>;
 }
 export declare const kai: KaiLogger;
+export {};