overai 1.4.0

package/dist/tools/tools.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Tools Facade - Simple API for accessing all built-in tools
+ *
+ * Usage:
+ *   import { tools } from 'praisonai';
+ *   const agent = new Agent({ tools: [tools.tavily(), tools.codeExecution()] });
+ */
+import type { PraisonTool } from './registry/types';
+import type { CodeExecutionConfig } from './builtins/code-execution';
+import type { TavilySearchConfig, TavilyExtractConfig, TavilyCrawlConfig } from './builtins/tavily';
+import type { ExaSearchConfig } from './builtins/exa';
+import type { PerplexitySearchConfig } from './builtins/perplexity';
+import type { ParallelSearchConfig } from './builtins/parallel';
+import type { FirecrawlScrapeConfig, FirecrawlCrawlConfig } from './builtins/firecrawl';
+import type { GuardConfig, RedactConfig, VerifyConfig } from './builtins/superagent';
+import type { ValyuSearchConfig } from './builtins/valyu';
+import type { CodeInterpreterConfig, BrowserConfig } from './builtins/bedrock-agentcore';
+import type { AirweaveSearchConfig } from './builtins/airweave';
+import type { CodeModeConfig } from './builtins/code-mode';
+import type { CustomToolConfig } from './builtins/custom';
+/**
+ * Register all built-in tools with the global registry
+ */
+export declare function registerBuiltinTools(): void;
+/**
+ * Tools facade - provides simple access to all built-in tools
+ */
+export declare const tools: {
+    codeExecution: (config?: CodeExecutionConfig) => PraisonTool<import("./builtins/code-execution").CodeExecutionInput, import("./builtins/code-execution").CodeExecutionOutput>;
+    executeCode: (config?: CodeExecutionConfig) => PraisonTool<import("./builtins/code-execution").CodeExecutionInput, import("./builtins/code-execution").CodeExecutionOutput>;
+    tavily: (config?: TavilySearchConfig) => PraisonTool<import("./builtins/tavily").TavilySearchInput, import("./builtins/tavily").TavilySearchResult>;
+    tavilySearch: (config?: TavilySearchConfig) => PraisonTool<import("./builtins/tavily").TavilySearchInput, import("./builtins/tavily").TavilySearchResult>;
+    tavilyExtract: (config?: TavilyExtractConfig) => PraisonTool<import("./builtins/tavily").TavilyExtractInput, import("./builtins/tavily").TavilyExtractResult>;
+    tavilyCrawl: (config?: TavilyCrawlConfig) => PraisonTool<import("./builtins/tavily").TavilyCrawlInput, import("./builtins/tavily").TavilyCrawlResult>;
+    exa: (config?: ExaSearchConfig) => PraisonTool<import("./builtins/exa").ExaSearchInput, import("./builtins/exa").ExaSearchResult>;
+    exaSearch: (config?: ExaSearchConfig) => PraisonTool<import("./builtins/exa").ExaSearchInput, import("./builtins/exa").ExaSearchResult>;
+    perplexity: (config?: PerplexitySearchConfig) => PraisonTool<import("./builtins/perplexity").PerplexitySearchInput, import("./builtins/perplexity").PerplexitySearchResult>;
+    perplexitySearch: (config?: PerplexitySearchConfig) => PraisonTool<import("./builtins/perplexity").PerplexitySearchInput, import("./builtins/perplexity").PerplexitySearchResult>;
+    parallel: (config?: ParallelSearchConfig) => PraisonTool<import("./builtins/parallel").ParallelSearchInput, import("./builtins/parallel").ParallelSearchResult>;
+    parallelSearch: (config?: ParallelSearchConfig) => PraisonTool<import("./builtins/parallel").ParallelSearchInput, import("./builtins/parallel").ParallelSearchResult>;
+    firecrawl: (config?: FirecrawlScrapeConfig) => PraisonTool<import("./builtins/firecrawl").FirecrawlScrapeInput, import("./builtins/firecrawl").FirecrawlScrapeResult>;
+    firecrawlScrape: (config?: FirecrawlScrapeConfig) => PraisonTool<import("./builtins/firecrawl").FirecrawlScrapeInput, import("./builtins/firecrawl").FirecrawlScrapeResult>;
+    firecrawlCrawl: (config?: FirecrawlCrawlConfig) => PraisonTool<import("./builtins/firecrawl").FirecrawlCrawlInput, import("./builtins/firecrawl").FirecrawlCrawlResult>;
+    guard: (config?: GuardConfig) => PraisonTool<import("./builtins/superagent").GuardInput, import("./builtins/superagent").GuardResult>;
+    redact: (config?: RedactConfig) => PraisonTool<import("./builtins/superagent").RedactInput, import("./builtins/superagent").RedactResult>;
+    verify: (config?: VerifyConfig) => PraisonTool<import("./builtins/superagent").VerifyInput, import("./builtins/superagent").VerifyResult>;
+    superagentGuard: (config?: GuardConfig) => PraisonTool<import("./builtins/superagent").GuardInput, import("./builtins/superagent").GuardResult>;
+    superagentRedact: (config?: RedactConfig) => PraisonTool<import("./builtins/superagent").RedactInput, import("./builtins/superagent").RedactResult>;
+    superagentVerify: (config?: VerifyConfig) => PraisonTool<import("./builtins/superagent").VerifyInput, import("./builtins/superagent").VerifyResult>;
+    valyuWebSearch: (config?: ValyuSearchConfig) => PraisonTool<import("./builtins/valyu").ValyuSearchInput, import("./builtins/valyu").ValyuSearchResult>;
+    valyuFinanceSearch: (config?: ValyuSearchConfig) => PraisonTool<import("./builtins/valyu").ValyuSearchInput, import("./builtins/valyu").ValyuSearchResult>;
+    valyuPaperSearch: (config?: ValyuSearchConfig) => PraisonTool<import("./builtins/valyu").ValyuSearchInput, import("./builtins/valyu").ValyuSearchResult>;
+    valyuBioSearch: (config?: ValyuSearchConfig) => PraisonTool<import("./builtins/valyu").ValyuSearchInput, import("./builtins/valyu").ValyuSearchResult>;
+    valyuPatentSearch: (config?: ValyuSearchConfig) => PraisonTool<import("./builtins/valyu").ValyuSearchInput, import("./builtins/valyu").ValyuSearchResult>;
+    valyuSecSearch: (config?: ValyuSearchConfig) => PraisonTool<import("./builtins/valyu").ValyuSearchInput, import("./builtins/valyu").ValyuSearchResult>;
+    valyuEconomicsSearch: (config?: ValyuSearchConfig) => PraisonTool<import("./builtins/valyu").ValyuSearchInput, import("./builtins/valyu").ValyuSearchResult>;
+    valyuCompanyResearch: (config?: ValyuSearchConfig) => PraisonTool<import("./builtins/valyu").ValyuSearchInput, import("./builtins/valyu").ValyuSearchResult>;
+    bedrockCodeInterpreter: (config?: CodeInterpreterConfig) => PraisonTool<import("./builtins/bedrock-agentcore").CodeInterpreterInput, import("./builtins/bedrock-agentcore").CodeInterpreterResult>;
+    bedrockBrowserNavigate: (config?: BrowserConfig) => PraisonTool<import("./builtins/bedrock-agentcore").BrowserNavigateInput, import("./builtins/bedrock-agentcore").BrowserResult>;
+    bedrockBrowserClick: (config?: BrowserConfig) => PraisonTool<import("./builtins/bedrock-agentcore").BrowserClickInput, import("./builtins/bedrock-agentcore").BrowserResult>;
+    bedrockBrowserFill: (config?: BrowserConfig) => PraisonTool<import("./builtins/bedrock-agentcore").BrowserFillInput, import("./builtins/bedrock-agentcore").BrowserResult>;
+    airweave: (config?: AirweaveSearchConfig) => PraisonTool<import("./builtins/airweave").AirweaveSearchInput, import("./builtins/airweave").AirweaveSearchResult>;
+    airweaveSearch: (config?: AirweaveSearchConfig) => PraisonTool<import("./builtins/airweave").AirweaveSearchInput, import("./builtins/airweave").AirweaveSearchResult>;
+    codeMode: (config?: CodeModeConfig) => PraisonTool<import("./builtins/code-mode").CodeModeInput, import("./builtins/code-mode").CodeModeResult>;
+    custom: <TInput = unknown, TOutput = unknown>(config: CustomToolConfig<TInput, TOutput>) => PraisonTool<TInput, TOutput>;
+    register: <TInput = unknown, TOutput = unknown>(config: CustomToolConfig<TInput, TOutput>) => PraisonTool<TInput, TOutput>;
+    fromNpm: (packageName: string, toolName?: string) => Promise<PraisonTool<unknown, unknown>>;
+    fromLocal: (filePath: string, toolName?: string) => Promise<PraisonTool<unknown, unknown>>;
+    getRegistry: () => import("./registry/registry").ToolsRegistry;
+    list: () => import("./registry/types").ToolMetadata[];
+    get: (id: string) => import("./registry/types").ToolMetadata | undefined;
+    create: <TConfig = unknown>(id: string, config?: TConfig) => PraisonTool<unknown, unknown>;
+};
+export default tools;

package/dist/tools/tools.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Tools Facade - Simple API for accessing all built-in tools
+ *
+ * Usage:
+ *   import { tools } from 'praisonai';
+ *   const agent = new Agent({ tools: [tools.tavily(), tools.codeExecution()] });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = void 0;
+exports.registerBuiltinTools = registerBuiltinTools;
+const registry_1 = require("./registry/registry");
+// Import all tool factories
+const code_execution_1 = require("./builtins/code-execution");
+const tavily_1 = require("./builtins/tavily");
+const exa_1 = require("./builtins/exa");
+const perplexity_1 = require("./builtins/perplexity");
+const parallel_1 = require("./builtins/parallel");
+const firecrawl_1 = require("./builtins/firecrawl");
+const superagent_1 = require("./builtins/superagent");
+const valyu_1 = require("./builtins/valyu");
+const bedrock_agentcore_1 = require("./builtins/bedrock-agentcore");
+const airweave_1 = require("./builtins/airweave");
+const code_mode_1 = require("./builtins/code-mode");
+const custom_1 = require("./builtins/custom");
+/**
+ * Register all built-in tools with the global registry
+ */
+function registerBuiltinTools() {
+    const registry = (0, registry_1.getToolsRegistry)();
+    // Code Execution
+    registry.register(code_execution_1.CODE_EXECUTION_METADATA, code_execution_1.createCodeExecutionTool);
+    // Tavily - register with both base ID and specific IDs
+    registry.register(tavily_1.TAVILY_METADATA, tavily_1.createTavilySearchTool);
+    registry.register({ ...tavily_1.TAVILY_METADATA, id: 'tavily-search' }, tavily_1.createTavilySearchTool);
+    registry.register({ ...tavily_1.TAVILY_METADATA, id: 'tavily-extract' }, tavily_1.createTavilyExtractTool);
+    registry.register({ ...tavily_1.TAVILY_METADATA, id: 'tavily-crawl' }, tavily_1.createTavilyCrawlTool);
+    // Exa
+    registry.register(exa_1.EXA_METADATA, exa_1.createExaSearchTool);
+    // Perplexity
+    registry.register(perplexity_1.PERPLEXITY_METADATA, perplexity_1.createPerplexitySearchTool);
+    // Parallel
+    registry.register(parallel_1.PARALLEL_METADATA, parallel_1.createParallelSearchTool);
+    // Firecrawl
+    registry.register({ ...firecrawl_1.FIRECRAWL_METADATA, id: 'firecrawl-scrape' }, firecrawl_1.createFirecrawlScrapeTool);
+    registry.register({ ...firecrawl_1.FIRECRAWL_METADATA, id: 'firecrawl-crawl' }, firecrawl_1.createFirecrawlCrawlTool);
+    // Superagent
+    registry.register({ ...superagent_1.SUPERAGENT_METADATA, id: 'superagent-guard' }, superagent_1.createSuperagentGuardTool);
+    registry.register({ ...superagent_1.SUPERAGENT_METADATA, id: 'superagent-redact' }, superagent_1.createSuperagentRedactTool);
+    registry.register({ ...superagent_1.SUPERAGENT_METADATA, id: 'superagent-verify' }, superagent_1.createSuperagentVerifyTool);
+    // Valyu
+    registry.register({ ...valyu_1.VALYU_METADATA, id: 'valyu-web' }, valyu_1.createValyuWebSearchTool);
+    registry.register({ ...valyu_1.VALYU_METADATA, id: 'valyu-finance' }, valyu_1.createValyuFinanceSearchTool);
+    registry.register({ ...valyu_1.VALYU_METADATA, id: 'valyu-paper' }, valyu_1.createValyuPaperSearchTool);
+    registry.register({ ...valyu_1.VALYU_METADATA, id: 'valyu-bio' }, valyu_1.createValyuBioSearchTool);
+    registry.register({ ...valyu_1.VALYU_METADATA, id: 'valyu-patent' }, valyu_1.createValyuPatentSearchTool);
+    registry.register({ ...valyu_1.VALYU_METADATA, id: 'valyu-sec' }, valyu_1.createValyuSecSearchTool);
+    registry.register({ ...valyu_1.VALYU_METADATA, id: 'valyu-economics' }, valyu_1.createValyuEconomicsSearchTool);
+    registry.register({ ...valyu_1.VALYU_METADATA, id: 'valyu-company' }, valyu_1.createValyuCompanyResearchTool);
+    // Bedrock AgentCore
+    registry.register({ ...bedrock_agentcore_1.BEDROCK_AGENTCORE_METADATA, id: 'bedrock-code-interpreter' }, bedrock_agentcore_1.createBedrockCodeInterpreterTool);
+    registry.register({ ...bedrock_agentcore_1.BEDROCK_AGENTCORE_METADATA, id: 'bedrock-browser-navigate' }, bedrock_agentcore_1.createBedrockBrowserNavigateTool);
+    registry.register({ ...bedrock_agentcore_1.BEDROCK_AGENTCORE_METADATA, id: 'bedrock-browser-click' }, bedrock_agentcore_1.createBedrockBrowserClickTool);
+    registry.register({ ...bedrock_agentcore_1.BEDROCK_AGENTCORE_METADATA, id: 'bedrock-browser-fill' }, bedrock_agentcore_1.createBedrockBrowserFillTool);
+    // Airweave
+    registry.register(airweave_1.AIRWEAVE_METADATA, airweave_1.createAirweaveSearchTool);
+    // Code Mode
+    registry.register(code_mode_1.CODE_MODE_METADATA, code_mode_1.createCodeModeTool);
+}
+/**
+ * Tools facade - provides simple access to all built-in tools
+ */
+exports.tools = {
+    // Code Execution (Vercel Sandbox)
+    codeExecution: (config) => (0, code_execution_1.codeExecution)(config),
+    executeCode: (config) => (0, code_execution_1.codeExecution)(config), // Alias
+    // Tavily
+    tavily: (config) => (0, tavily_1.tavilySearch)(config),
+    tavilySearch: (config) => (0, tavily_1.tavilySearch)(config),
+    tavilyExtract: (config) => (0, tavily_1.tavilyExtract)(config),
+    tavilyCrawl: (config) => (0, tavily_1.tavilyCrawl)(config),
+    // Exa
+    exa: (config) => (0, exa_1.exaSearch)(config),
+    exaSearch: (config) => (0, exa_1.exaSearch)(config),
+    // Perplexity
+    perplexity: (config) => (0, perplexity_1.perplexitySearch)(config),
+    perplexitySearch: (config) => (0, perplexity_1.perplexitySearch)(config),
+    // Parallel
+    parallel: (config) => (0, parallel_1.parallelSearch)(config),
+    parallelSearch: (config) => (0, parallel_1.parallelSearch)(config),
+    // Firecrawl
+    firecrawl: (config) => (0, firecrawl_1.firecrawlScrape)(config),
+    firecrawlScrape: (config) => (0, firecrawl_1.firecrawlScrape)(config),
+    firecrawlCrawl: (config) => (0, firecrawl_1.firecrawlCrawl)(config),
+    // Superagent (Security)
+    guard: (config) => (0, superagent_1.superagentGuard)(config),
+    redact: (config) => (0, superagent_1.superagentRedact)(config),
+    verify: (config) => (0, superagent_1.superagentVerify)(config),
+    superagentGuard: (config) => (0, superagent_1.superagentGuard)(config),
+    superagentRedact: (config) => (0, superagent_1.superagentRedact)(config),
+    superagentVerify: (config) => (0, superagent_1.superagentVerify)(config),
+    // Valyu (Domain Search)
+    valyuWebSearch: (config) => (0, valyu_1.valyuWebSearch)(config),
+    valyuFinanceSearch: (config) => (0, valyu_1.valyuFinanceSearch)(config),
+    valyuPaperSearch: (config) => (0, valyu_1.valyuPaperSearch)(config),
+    valyuBioSearch: (config) => (0, valyu_1.valyuBioSearch)(config),
+    valyuPatentSearch: (config) => (0, valyu_1.valyuPatentSearch)(config),
+    valyuSecSearch: (config) => (0, valyu_1.valyuSecSearch)(config),
+    valyuEconomicsSearch: (config) => (0, valyu_1.valyuEconomicsSearch)(config),
+    valyuCompanyResearch: (config) => (0, valyu_1.valyuCompanyResearch)(config),
+    // Bedrock AgentCore
+    bedrockCodeInterpreter: (config) => (0, bedrock_agentcore_1.bedrockCodeInterpreter)(config),
+    bedrockBrowserNavigate: (config) => (0, bedrock_agentcore_1.bedrockBrowserNavigate)(config),
+    bedrockBrowserClick: (config) => (0, bedrock_agentcore_1.bedrockBrowserClick)(config),
+    bedrockBrowserFill: (config) => (0, bedrock_agentcore_1.bedrockBrowserFill)(config),
+    // Airweave
+    airweave: (config) => (0, airweave_1.airweaveSearch)(config),
+    airweaveSearch: (config) => (0, airweave_1.airweaveSearch)(config),
+    // Code Mode
+    codeMode: (config) => (0, code_mode_1.codeMode)(config),
+    // Custom Tools
+    custom: (config) => (0, custom_1.createCustomTool)(config),
+    register: (config) => (0, custom_1.registerCustomTool)(config),
+    fromNpm: (packageName, toolName) => (0, custom_1.registerNpmTool)(packageName, toolName),
+    fromLocal: (filePath, toolName) => (0, custom_1.registerLocalTool)(filePath, toolName),
+    // Registry access
+    getRegistry: () => (0, registry_1.getToolsRegistry)(),
+    list: () => (0, registry_1.getToolsRegistry)().list(),
+    get: (id) => (0, registry_1.getToolsRegistry)().getMetadata(id),
+    create: (id, config) => (0, registry_1.getToolsRegistry)().create(id, config),
+};
+// Export the tools object as default
+exports.default = exports.tools;

package/dist/utils/logger.d.ts

@@ -0,0 +1,25 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export declare class Logger {
+    private static level;
+    private static verbose;
+    private static pretty;
+    private static getCircularReplacer;
+    private static formatContext;
+    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

@@ -0,0 +1,149 @@
+"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";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    static getCircularReplacer() {
+        const seen = new WeakSet();
+        return (key, value) => {
+            if (typeof value === "object" && value !== null) {
+                if (seen.has(value)) {
+                    return "[Circular]";
+                }
+                seen.add(value);
+            }
+            return value;
+        };
+    }
+    static formatContext(context) {
+        try {
+            return JSON.stringify(context, this.getCircularReplacer(), 2);
+        }
+        catch (error) {
+            return String(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 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 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 async error(message, context) {
+        if (this.level <= LogLevel.ERROR) {
+            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,21 @@
+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 plain(text: string): Promise<void>;
+    static dim(text: string): Promise<void>;
+    static newline(): Promise<void>;
+    static heading(text: string): 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,248 @@
+"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 plain(text) {
+        if (!await this.init()) {
+            console.log(text);
+            return;
+        }
+        console.log(text);
+    }
+    static async dim(text) {
+        if (!await this.init()) {
+            console.log(text);
+            return;
+        }
+        console.log(chalk.dim(text));
+    }
+    static async newline() {
+        console.log('');
+    }
+    static async heading(text) {
+        if (!await this.init()) {
+            console.log(`\n${text}\n`);
+            return;
+        }
+        console.log(chalk.bold.underline(`\n${text}`));
+    }
+    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;