praisonai 1.0.11 → 1.0.13

package/dist/agent/simple.d.ts

@@ -2,17 +2,20 @@ export interface SimpleAgentConfig {
     instructions: string;
     name?: string;
     verbose?: boolean;
+    pretty?: boolean;
     llm?: string;
     markdown?: boolean;
+    stream?: boolean;
 }
 export declare class Agent {
     private instructions;
     name: string;
     private verbose;
+    private pretty;
     private llm;
     private markdown;
+    private stream;
     private llmService;
-    private result;
     constructor(config: SimpleAgentConfig);
     private createSystemPrompt;
     start(prompt: string, previousResult?: string): Promise<string>;
@@ -24,12 +27,14 @@ export interface PraisonAIAgentsConfig {
     agents: Agent[];
     tasks: string[];
     verbose?: boolean;
+    pretty?: boolean;
     process?: 'sequential' | 'parallel';
 }
 export declare class PraisonAIAgents {
     private agents;
     private tasks;
     private verbose;
+    private pretty;
     private process;
     constructor(config: PraisonAIAgentsConfig);
     start(): Promise<string[]>;

package/dist/agent/simple.js

@@ -2,41 +2,51 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PraisonAIAgents = exports.Agent = void 0;
 const openai_1 = require("../llm/openai");
+const logger_1 = require("../utils/logger");
 class Agent {
     constructor(config) {
-        this.result = null;
         this.instructions = config.instructions;
         this.name = config.name || `Agent_${Math.random().toString(36).substr(2, 9)}`;
-        this.verbose = config.verbose || false;
+        this.verbose = config.verbose ?? process.env.PRAISON_VERBOSE !== 'false';
+        this.pretty = config.pretty ?? process.env.PRAISON_PRETTY === 'true';
         this.llm = config.llm || 'gpt-4o-mini';
-        this.markdown = config.markdown || true;
+        this.markdown = config.markdown ?? true;
+        this.stream = config.stream ?? true;
         this.llmService = new openai_1.OpenAIService(this.llm);
+        // Configure logging
+        logger_1.Logger.setVerbose(this.verbose);
+        logger_1.Logger.setPretty(this.pretty);
     }
     createSystemPrompt() {
-        return `${this.instructions}
-Please provide detailed, accurate, and helpful responses.
-Format your response in markdown if appropriate.`;
+        let prompt = this.instructions;
+        if (this.markdown) {
+            prompt += '\nPlease format your response in markdown.';
+        }
+        return prompt;
     }
     async start(prompt, previousResult) {
-        if (this.verbose) {
-            console.log(`Agent ${this.name} starting with prompt: ${prompt}`);
-        }
+        await logger_1.Logger.debug(`Agent ${this.name} starting with prompt: ${prompt}`);
         try {
             // Replace placeholder with previous result if available
-            const finalPrompt = previousResult
-                ? prompt.replace('{previous_result}', previousResult)
-                : prompt;
-            if (this.verbose) {
-                console.log('Generating response (streaming)...');
-                await this.llmService.streamText(finalPrompt, this.createSystemPrompt(), 0.7, (token) => process.stdout.write(token));
-                console.log('\n');
+            if (previousResult) {
+                prompt = prompt.replace('{{previous}}', previousResult);
+            }
+            let response;
+            if (this.stream) {
+                let fullResponse = '';
+                await this.llmService.streamText(prompt, this.createSystemPrompt(), 0.7, (token) => {
+                    process.stdout.write(token);
+                    fullResponse += token;
+                });
+                response = fullResponse;
             }
-            // Get the final response
-            this.result = await this.llmService.generateText(finalPrompt, this.createSystemPrompt());
-            return this.result;
+            else {
+                response = await this.llmService.generateText(prompt, this.createSystemPrompt());
+            }
+            return response;
         }
         catch (error) {
-            console.error(`Error executing prompt: ${error}`);
+            await logger_1.Logger.error('Error in agent execution', error);
             throw error;
         }
     }
@@ -48,7 +58,7 @@ Format your response in markdown if appropriate.`;
         return this.start(this.instructions, previousResult);
     }
     getResult() {
-        return this.result;
+        return null;
     }
 }
 exports.Agent = Agent;
@@ -57,12 +67,14 @@ class PraisonAIAgents {
         this.agents = config.agents;
         this.tasks = config.tasks;
         this.verbose = config.verbose || false;
+        this.pretty = config.pretty || false;
         this.process = config.process || 'sequential';
+        // Configure logging
+        logger_1.Logger.setVerbose(config.verbose ?? process.env.PRAISON_VERBOSE !== 'false');
+        logger_1.Logger.setPretty(config.pretty ?? process.env.PRAISON_PRETTY === 'true');
     }
     async start() {
-        if (this.verbose) {
-            console.log('Starting PraisonAI Agents execution...');
-        }
+        await logger_1.Logger.debug('Starting PraisonAI Agents execution...');
         let results;
         if (this.process === 'parallel') {
             results = await Promise.all(this.tasks.map((task, index) => this.agents[index].start(task)));
@@ -88,9 +100,7 @@ class PraisonAIAgents {
             const agent = this.agents[i];
             const task = this.tasks[i];
             const previousResult = i > 0 ? results[i - 1] : undefined;
-            if (this.verbose) {
-                console.log(`Agent ${agent.name} starting with prompt: ${task}`);
-            }
+            await logger_1.Logger.info(`Agent ${agent.name} starting with prompt: ${task}`);
             const result = await agent.start(task, previousResult);
             results.push(result);
         }

package/dist/agent/types.js

@@ -91,7 +91,7 @@ class PraisonAIAgents {
         logger_1.Logger.debug('PraisonAIAgents initialized', { config });
     }
     async start() {
-        logger_1.Logger.info('Starting PraisonAI Agents execution...');
+        logger_1.Logger.debug('Starting PraisonAI Agents execution...');
         logger_1.Logger.debug('Starting with process mode:', this.process);
         let results;
         switch (this.process) {

package/dist/llm/openai.d.ts

@@ -2,14 +2,19 @@ export interface LLMResponse {
     content: string;
     role: string;
 }
+type ChatRole = 'system' | 'user' | 'assistant';
+interface ChatMessage {
+    role: ChatRole;
+    content: string;
+}
 export declare class OpenAIService {
-    private client;
     private model;
+    private client;
     constructor(model?: string);
+    private getClient;
     generateText(prompt: string, systemPrompt?: string, temperature?: number): Promise<string>;
+    generateChat(messages: ChatMessage[], temperature?: number): Promise<LLMResponse>;
     streamText(prompt: string, systemPrompt: string | undefined, temperature: number | undefined, onToken: (token: string) => void): Promise<void>;
-    chatCompletion(messages: Array<{
-        role: 'system' | 'user' | 'assistant';
-        content: string;
-    }>, temperature?: number): Promise<LLMResponse>;
+    chatCompletion(messages: ChatMessage[], temperature?: number): Promise<LLMResponse>;
 }
+export {};

package/dist/llm/openai.js

@@ -7,80 +7,140 @@ exports.OpenAIService = void 0;
 const openai_1 = __importDefault(require("openai"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const logger_1 = require("../utils/logger");
+// Load environment variables once at the application level
 dotenv_1.default.config();
-class OpenAIService {
-    constructor(model = 'gpt-4o-mini') {
-        if (!process.env.OPENAI_API_KEY) {
-            throw new Error('OPENAI_API_KEY not found in environment variables');
-        }
-        this.client = new openai_1.default({
+if (!process.env.OPENAI_API_KEY) {
+    throw new Error('OPENAI_API_KEY not found in environment variables');
+}
+// Singleton instance for OpenAI client
+let openAIInstance = null;
+// Get cached OpenAI client instance
+async function getOpenAIClient() {
+    if (!openAIInstance) {
+        openAIInstance = new openai_1.default({
             apiKey: process.env.OPENAI_API_KEY
         });
+        await logger_1.Logger.success('OpenAI client initialized');
+    }
+    return openAIInstance;
+}
+class OpenAIService {
+    constructor(model = 'gpt-4o-mini') {
+        this.client = null;
         this.model = model;
         logger_1.Logger.debug(`OpenAIService initialized with model: ${model}`);
     }
+    // Lazy initialization of client
+    async getClient() {
+        if (!this.client) {
+            this.client = await getOpenAIClient();
+        }
+        return this.client;
+    }
     async generateText(prompt, systemPrompt = '', temperature = 0.7) {
-        logger_1.Logger.debug('Generating text with OpenAI', {
-            model: this.model,
-            temperature,
-            systemPrompt,
-            prompt
-        });
-        const completion = await this.client.chat.completions.create({
-            model: this.model,
-            messages: [
-                { role: 'system', content: systemPrompt },
-                { role: 'user', content: prompt }
-            ],
-            temperature,
-        });
-        const response = completion.choices[0].message.content || '';
-        logger_1.Logger.debug('OpenAI response received', { response });
-        return response;
+        await logger_1.Logger.startSpinner('Generating text with OpenAI...');
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: 'system', content: systemPrompt });
+        }
+        messages.push({ role: 'user', content: prompt });
+        try {
+            const completion = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages
+            }));
+            const response = completion.choices[0]?.message?.content;
+            if (!response) {
+                throw new Error('No response from OpenAI');
+            }
+            await logger_1.Logger.stopSpinner(true);
+            await logger_1.Logger.section('Generated Response', response);
+            return response;
+        }
+        catch (error) {
+            await logger_1.Logger.stopSpinner(false);
+            await logger_1.Logger.error('Error generating text', error);
+            throw error;
+        }
+    }
+    async generateChat(messages, temperature = 0.7) {
+        await logger_1.Logger.startSpinner('Generating chat response...');
+        try {
+            const completion = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages
+            }));
+            const response = completion.choices[0]?.message;
+            if (!response) {
+                throw new Error('No response from OpenAI');
+            }
+            await logger_1.Logger.stopSpinner(true);
+            const result = {
+                content: response.content || '',
+                role: response.role
+            };
+            await logger_1.Logger.section('Chat Response', result.content);
+            return result;
+        }
+        catch (error) {
+            await logger_1.Logger.stopSpinner(false);
+            await logger_1.Logger.error('Error generating chat response', error);
+            throw error;
+        }
     }
     async streamText(prompt, systemPrompt = '', temperature = 0.7, onToken) {
-        logger_1.Logger.debug('Streaming text with OpenAI', {
-            model: this.model,
-            temperature,
-            systemPrompt,
-            prompt
-        });
-        const stream = await this.client.chat.completions.create({
+        await logger_1.Logger.debug('Starting text stream...', {
             model: this.model,
-            messages: [
-                { role: 'system', content: systemPrompt },
-                { role: 'user', content: prompt }
-            ],
-            temperature,
-            stream: true,
+            temperature
         });
-        let fullResponse = '';
-        for await (const chunk of stream) {
-            const content = chunk.choices[0]?.delta?.content;
-            if (content) {
-                onToken(content);
-                fullResponse += content;
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: 'system', content: systemPrompt });
+        }
+        messages.push({ role: 'user', content: prompt });
+        try {
+            const stream = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages,
+                stream: true,
+            }));
+            let fullResponse = '';
+            for await (const chunk of stream) {
+                const token = chunk.choices[0]?.delta?.content || '';
+                fullResponse += token;
+                onToken(token);
             }
+            await logger_1.Logger.success('Stream completed successfully');
+        }
+        catch (error) {
+            await logger_1.Logger.error('Error in text stream', error);
+            throw error;
         }
-        logger_1.Logger.debug('OpenAI streaming completed', { fullResponse });
     }
     async chatCompletion(messages, temperature = 0.7) {
-        logger_1.Logger.debug('Chat completion with OpenAI', {
-            model: this.model,
-            temperature,
-            messages
-        });
-        const completion = await this.client.chat.completions.create({
-            model: this.model,
-            messages,
-            temperature,
-        });
-        const response = {
-            content: completion.choices[0].message.content || '',
-            role: completion.choices[0].message.role
-        };
-        logger_1.Logger.debug('OpenAI chat completion response received', { response });
-        return response;
+        await logger_1.Logger.startSpinner('Chat completion with OpenAI...');
+        try {
+            const completion = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages
+            }));
+            const response = {
+                content: completion.choices[0].message.content || '',
+                role: completion.choices[0].message.role
+            };
+            await logger_1.Logger.stopSpinner(true);
+            await logger_1.Logger.section('Chat Completion Response', response.content);
+            return response;
+        }
+        catch (error) {
+            await logger_1.Logger.stopSpinner(false);
+            await logger_1.Logger.error('Error in chat completion', error);
+            throw error;
+        }
     }
 }
 exports.OpenAIService = OpenAIService;

package/dist/utils/logger.d.ts

@@ -6,10 +6,20 @@ export declare enum LogLevel {
 }
 export declare class Logger {
     private static level;
+    private static verbose;
+    private static pretty;
     private static getCircularReplacer;
     private static formatContext;
-    static debug(message: string, context?: any): void;
-    static info(message: string, context?: any): void;
-    static warn(message: string, context?: any): void;
-    static error(message: string, context?: any): void;
+    static setVerbose(verbose: boolean): void;
+    static setPretty(pretty: boolean): void;
+    static debug(message: string, context?: any): Promise<void>;
+    static info(message: string, context?: any): Promise<void>;
+    static warn(message: string, context?: any): Promise<void>;
+    static error(message: string, context?: any): Promise<void>;
+    static success(message: string, data?: unknown): Promise<void>;
+    static startSpinner(text: string): Promise<void>;
+    static updateSpinner(text: string): Promise<void>;
+    static stopSpinner(success?: boolean): Promise<void>;
+    static table(headers: string[], data: (string | number)[][]): Promise<void>;
+    static section(title: string, content: string): Promise<void>;
 }

package/dist/utils/logger.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = exports.LogLevel = void 0;
+const pretty_logger_1 = require("./pretty-logger");
 var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
@@ -12,9 +13,9 @@ class Logger {
     static getCircularReplacer() {
         const seen = new WeakSet();
         return (key, value) => {
-            if (typeof value === 'object' && value !== null) {
+            if (typeof value === "object" && value !== null) {
                 if (seen.has(value)) {
-                    return '[Circular]';
+                    return "[Circular]";
                 }
                 seen.add(value);
             }
@@ -26,29 +27,123 @@ class Logger {
             return JSON.stringify(context, this.getCircularReplacer(), 2);
         }
         catch (error) {
-            return '[Unable to stringify context]';
+            return String(context);
         }
     }
-    static debug(message, context) {
-        if (this.level <= LogLevel.DEBUG) {
-            console.log(`[DEBUG] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+    static setVerbose(verbose) {
+        this.verbose = verbose;
+    }
+    static setPretty(pretty) {
+        this.pretty = pretty;
+    }
+    static async debug(message, context) {
+        if (this.level <= LogLevel.DEBUG && this.verbose) {
+            if (this.pretty) {
+                await pretty_logger_1.PrettyLogger.info(message, context);
+            }
+            else {
+                console.log(`[DEBUG] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+            }
         }
     }
-    static info(message, context) {
-        if (this.level <= LogLevel.INFO) {
-            console.log(`[INFO] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+    static async info(message, context) {
+        if (this.level <= LogLevel.INFO && this.verbose) {
+            if (this.pretty) {
+                await pretty_logger_1.PrettyLogger.info(message, context);
+            }
+            else {
+                console.log(`[INFO] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+            }
         }
     }
-    static warn(message, context) {
-        if (this.level <= LogLevel.WARN) {
-            console.warn(`[WARN] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+    static async warn(message, context) {
+        if (this.level <= LogLevel.WARN && this.verbose) {
+            if (this.pretty) {
+                await pretty_logger_1.PrettyLogger.warning(message, context);
+            }
+            else {
+                console.warn(`[WARN] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+            }
         }
     }
-    static error(message, context) {
+    static async error(message, context) {
         if (this.level <= LogLevel.ERROR) {
-            console.error(`[ERROR] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+            if (this.pretty) {
+                await pretty_logger_1.PrettyLogger.error(message, context);
+            }
+            else {
+                console.error(`[ERROR] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+            }
+        }
+    }
+    static async success(message, data) {
+        if (!this.verbose)
+            return;
+        if (this.pretty) {
+            await pretty_logger_1.PrettyLogger.success(message, data);
+        }
+        else {
+            console.log(`✓ ${message}`);
+            if (data) {
+                console.log(data);
+            }
+        }
+    }
+    static async startSpinner(text) {
+        if (!this.verbose)
+            return;
+        if (this.pretty) {
+            await pretty_logger_1.PrettyLogger.startSpinner(text);
+        }
+        else {
+            console.log(`⟳ ${text}`);
+        }
+    }
+    static async updateSpinner(text) {
+        if (!this.verbose)
+            return;
+        if (this.pretty) {
+            await pretty_logger_1.PrettyLogger.updateSpinner(text);
+        }
+        else {
+            console.log(`⟳ ${text}`);
+        }
+    }
+    static async stopSpinner(success = true) {
+        if (!this.verbose)
+            return;
+        if (this.pretty) {
+            await pretty_logger_1.PrettyLogger.stopSpinner(success);
+        }
+        else {
+            // Already logged in startSpinner
+        }
+    }
+    static async table(headers, data) {
+        if (!this.verbose)
+            return;
+        if (this.pretty) {
+            await pretty_logger_1.PrettyLogger.table(headers, data);
+        }
+        else {
+            console.log(headers.join('\t'));
+            data.forEach(row => console.log(row.join('\t')));
+        }
+    }
+    static async section(title, content) {
+        if (!this.verbose)
+            return;
+        if (this.pretty) {
+            await pretty_logger_1.PrettyLogger.section(title, content);
+        }
+        else {
+            console.log(`\n=== ${title} ===`);
+            console.log(content);
+            console.log('='.repeat(title.length + 8));
         }
     }
 }
 exports.Logger = Logger;
 Logger.level = process.env.LOGLEVEL === 'debug' ? LogLevel.DEBUG : LogLevel.INFO;
+Logger.verbose = true;
+Logger.pretty = false;

package/dist/utils/pretty-logger.d.ts

@@ -0,0 +1,17 @@
+export declare class PrettyLogger {
+    private static spinner;
+    private static lastSpinnerText;
+    private static initialized;
+    private static isLoaded;
+    private static init;
+    static showTitle(text: string): Promise<void>;
+    static info(message: string, data?: unknown): Promise<void>;
+    static success(message: string, data?: unknown): Promise<void>;
+    static error(message: string, error?: unknown): Promise<void>;
+    static warning(message: string, data?: unknown): Promise<void>;
+    static startSpinner(text: string): Promise<void>;
+    static updateSpinner(text: string): Promise<void>;
+    static stopSpinner(success?: boolean): Promise<void>;
+    static table(headers: string[], data: (string | number)[][]): Promise<void>;
+    static section(title: string, content: string): Promise<void>;
+}

package/dist/utils/pretty-logger.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrettyLogger = void 0;
+// We'll load these dynamically since they're ES modules
+let chalk;
+let boxen;
+let ora;
+let Table;
+let figlet;
+// Load dependencies dynamically
+async function loadDependencies() {
+    try {
+        const imports = await Promise.all([
+            Promise.resolve().then(() => __importStar(require('chalk'))),
+            Promise.resolve().then(() => __importStar(require('boxen'))),
+            Promise.resolve().then(() => __importStar(require('ora'))),
+            Promise.resolve().then(() => __importStar(require('cli-table3'))),
+            Promise.resolve().then(() => __importStar(require('figlet')))
+        ]);
+        [chalk, boxen, ora, Table, figlet] = imports.map(imp => imp.default);
+        return true;
+    }
+    catch (error) {
+        console.warn('Pretty logging dependencies not available, falling back to basic logging');
+        return false;
+    }
+}
+class PrettyLogger {
+    static async init() {
+        if (!this.initialized) {
+            this.isLoaded = await loadDependencies();
+            this.initialized = true;
+        }
+        return this.isLoaded;
+    }
+    static async showTitle(text) {
+        if (!await this.init()) {
+            console.log(text);
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            figlet(text, (err, data) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                if (data) {
+                    console.log(chalk.cyan(data));
+                }
+                resolve();
+            });
+        });
+    }
+    static async info(message, data) {
+        if (!await this.init()) {
+            console.log(`ℹ ${message}`);
+            if (data)
+                console.log(data);
+            return;
+        }
+        console.log(chalk.blue('ℹ'), chalk.blue(message));
+        if (data) {
+            console.log(boxen(JSON.stringify(data, null, 2), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'blue'
+            }));
+        }
+    }
+    static async success(message, data) {
+        if (!await this.init()) {
+            console.log(`✓ ${message}`);
+            if (data)
+                console.log(data);
+            return;
+        }
+        console.log(chalk.green('✓'), chalk.green(message));
+        if (data) {
+            console.log(boxen(JSON.stringify(data, null, 2), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'green'
+            }));
+        }
+    }
+    static async error(message, error) {
+        if (!await this.init()) {
+            console.error(`✗ ${message}`);
+            if (error)
+                console.error(error);
+            return;
+        }
+        console.log(chalk.red('✗'), chalk.red(message));
+        if (error) {
+            console.log(boxen(JSON.stringify(error, null, 2), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'red'
+            }));
+        }
+    }
+    static async warning(message, data) {
+        if (!await this.init()) {
+            console.warn(`⚠ ${message}`);
+            if (data)
+                console.warn(data);
+            return;
+        }
+        console.log(chalk.yellow('⚠'), chalk.yellow(message));
+        if (data) {
+            console.log(boxen(JSON.stringify(data, null, 2), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'yellow'
+            }));
+        }
+    }
+    static async startSpinner(text) {
+        if (!await this.init()) {
+            console.log(`⟳ ${text}`);
+            return;
+        }
+        this.lastSpinnerText = text;
+        this.spinner = ora({
+            text: chalk.cyan(text),
+            color: 'cyan'
+        }).start();
+    }
+    static async updateSpinner(text) {
+        if (!await this.init()) {
+            console.log(`⟳ ${text}`);
+            return;
+        }
+        if (this.spinner) {
+            this.lastSpinnerText = text;
+            this.spinner.text = chalk.cyan(text);
+        }
+    }
+    static async stopSpinner(success = true) {
+        if (!await this.init())
+            return;
+        if (this.spinner) {
+            if (success) {
+                this.spinner.succeed(chalk.green(this.lastSpinnerText));
+            }
+            else {
+                this.spinner.fail(chalk.red(this.lastSpinnerText));
+            }
+            this.spinner = null;
+        }
+    }
+    static async table(headers, data) {
+        if (!await this.init()) {
+            console.log(headers.join('\t'));
+            data.forEach(row => console.log(row.join('\t')));
+            return;
+        }
+        const table = new Table({
+            head: headers.map(h => chalk.cyan(h)),
+            style: {
+                head: [],
+                border: []
+            }
+        });
+        data.forEach(row => table.push(row));
+        console.log(table.toString());
+    }
+    static async section(title, content) {
+        if (!await this.init()) {
+            console.log(`\n=== ${title} ===`);
+            console.log(content);
+            console.log('='.repeat(title.length + 8));
+            return;
+        }
+        console.log('\n' + boxen(chalk.bold(title) + '\n\n' + content, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'double',
+            borderColor: 'cyan'
+        }));
+    }
+}
+exports.PrettyLogger = PrettyLogger;
+PrettyLogger.spinner = null;
+PrettyLogger.lastSpinnerText = '';
+PrettyLogger.initialized = false;
+PrettyLogger.isLoaded = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praisonai",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "PraisonAI TypeScript AI Agents Framework - Node.js, npm, and Javascript AI Agents Framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,11 +43,12 @@
   "author": "Mervin Praison",
   "license": "MIT",
   "devDependencies": {
+    "@types/figlet": "^1.7.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.12.0",
     "@typescript-eslint/eslint-plugin": "^8.22.0",
     "@typescript-eslint/parser": "^8.22.0",
-    "eslint": "^8.57.0",
+    "eslint": "^9.19.0",
     "jest": "^29.7.0",
     "rimraf": "^5.0.5",
     "ts-jest": "^29.1.2",
@@ -56,11 +57,23 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
-    "axios": "^1.6.7",
-    "dotenv": "^16.4.1",
-    "fast-xml-parser": "^4.3.4",
-    "openai": "^4.24.7",
-    "praisonai": "^1.0.10"
+    "axios": "^1.7.9",
+    "dotenv": "^16.4.7",
+    "fast-xml-parser": "^4.5.1",
+    "node-fetch": "^3.3.2",
+    "openai": "^4.81.0",
+    "praisonai": "^1.0.12"
+  },
+  "optionalDependencies": {
+    "boxen": "^7.1.1",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.3",
+    "figlet": "^1.7.0",
+    "ora": "^5.4.1"
+  },
+  "overrides": {
+    "whatwg-url": "^14.1.0",
+    "node-fetch": "^3.3.2"
   },
   "engines": {
     "node": ">=14.0.0"