@enactprotocol/shared 1.2.11 → 2.0.0

package/dist/utils/env-loader.js

@@ -1,270 +0,0 @@
-// src/utils/env-loader.ts - Environment variable loader for Enact tools with package namespace support
-import { join } from "path";
-import { homedir } from "os";
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { config as loadDotenv } from "dotenv";
-// Configuration paths
-const CONFIG_DIR = join(homedir(), ".enact");
-/**
- * Extract package namespace from tool name (excluding tool name)
- * e.g., "kgroves88/dagger/social/bluesky-poster" -> "kgroves88/dagger/social"
- */
-function extractPackageNamespace(toolName) {
-    const parts = toolName.split("/");
-    if (parts.length < 2) {
-        throw new Error('Tool name must be in format "org/package" or "org/package/tool"');
-    }
-    // Use all path parts except the last one (tool name)
-    // For tools like "kgroves88/dagger/social/bluesky-poster",
-    // we want the package path "kgroves88/dagger/social"
-    if (parts.length >= 2) {
-        return parts.slice(0, -1).join("/");
-    }
-    return parts[0]; // fallback for edge cases
-}
-/**
- * Get the environment file path for a package namespace
- */
-function getPackageEnvPath(packageNamespace) {
-    return join(CONFIG_DIR, "env", packageNamespace, ".env");
-}
-/**
- * Simple decryption for encrypted values
- */
-function decryptValue(encryptedValue) {
-    try {
-        return Buffer.from(encryptedValue, "base64").toString("utf8");
-    }
-    catch {
-        return encryptedValue; // Return as-is if decryption fails
-    }
-}
-/**
- * Read environment configuration for a package namespace
- */
-async function readPackageEnvConfig(packageNamespace) {
-    const envFile = getPackageEnvPath(packageNamespace);
-    if (!existsSync(envFile)) {
-        return { variables: {} };
-    }
-    try {
-        const data = await readFile(envFile, "utf8");
-        // Check if it's a simple .env file (KEY=value format) or JSON
-        if (data.trim().startsWith("{")) {
-            // It's JSON format (legacy package-managed variables)
-            return JSON.parse(data);
-        }
-        else {
-            // It's simple .env format (project mode), return empty since these are handled separately
-            return { variables: {} };
-        }
-    }
-    catch (error) {
-        // Only warn if it's not a simple .env file parsing issue
-        if (!error.message.includes("Unexpected token")) {
-            console.warn(`Failed to read env config from ${envFile}: ${error.message}`);
-        }
-        return { variables: {} };
-    }
-}
-/**
- * Load environment variables from Enact configuration for a specific package namespace
- */
-export async function loadPackageEnvironmentVariables(packageNamespace) {
-    const config = await readPackageEnvConfig(packageNamespace);
-    const envVars = {};
-    // Load variables from the package namespace
-    for (const [name, envVar] of Object.entries(config.variables)) {
-        const value = envVar.encrypted ? decryptValue(envVar.value) : envVar.value;
-        envVars[name] = value;
-    }
-    return envVars;
-}
-/**
- * Load environment variables from a package-based .env file
- */
-function loadPackageEnvFile(toolName) {
-    if (!toolName) {
-        return {};
-    }
-    try {
-        const packageNamespace = extractPackageNamespace(toolName);
-        const packageEnvPath = getPackageEnvPath(packageNamespace);
-        if (!existsSync(packageEnvPath)) {
-            return {};
-        }
-        // Load .env file and return the parsed variables
-        const result = loadDotenv({ path: packageEnvPath });
-        return result.parsed || {};
-    }
-    catch (error) {
-        console.warn(`Warning: Failed to load package .env file: ${error.message}`);
-        return {};
-    }
-}
-/**
- * Resolve environment variables for a tool definition with package namespace support
- * Combines system environment, Enact package configuration, and tool-specific requirements
- * Following the Enact protocol format:
- * env:
- *   VARIABLE_NAME:
- *     description: string
- *     source: string
- *     required: boolean
- *     default: string (optional)
- */
-export async function resolveToolEnvironmentVariables(toolName, toolEnvConfig) {
-    // Start with system environment variables
-    const resolved = { ...process.env };
-    // Load package .env file (if it exists) - priority 2
-    const packageEnvVars = loadPackageEnvFile(toolName);
-    Object.assign(resolved, packageEnvVars);
-    // Load package-specific environment variables if we have a tool name - priority 3 (highest)
-    if (toolName) {
-        try {
-            const packageNamespace = extractPackageNamespace(toolName);
-            const packageJsonEnvVars = await loadPackageEnvironmentVariables(packageNamespace);
-            // Override with package-managed JSON variables (highest priority)
-            Object.assign(resolved, packageJsonEnvVars);
-        }
-        catch (error) {
-            // If we can't extract package namespace, continue without package env vars
-            console.warn(`Warning: Could not load package environment variables: ${error.message}`);
-        }
-    }
-    const missing = [];
-    // Check tool-specific environment requirements following Enact protocol
-    if (toolEnvConfig) {
-        for (const [varName, config] of Object.entries(toolEnvConfig)) {
-            if (typeof config === "object" && config !== null) {
-                // Enact protocol: each env var has description, source, required, and optional default
-                const isRequired = config.required === true;
-                const defaultValue = config.default;
-                const source = config.source;
-                // Check if variable is already resolved
-                if (!(varName in resolved) || resolved[varName] === "") {
-                    if (defaultValue !== undefined) {
-                        resolved[varName] = String(defaultValue);
-                    }
-                    else if (isRequired) {
-                        missing.push(varName);
-                    }
-                }
-                // Handle different sources as specified in the Enact protocol
-                if (source && resolved[varName]) {
-                    // The source field tells us where the value should come from
-                    // For now, we'll just ensure the variable is available
-                    // In the future, this could be extended to support different sources
-                    // like "user", "system", "config", etc.
-                }
-            }
-        }
-    }
-    // Generate and show configuration link if there are missing variables
-    let configLink;
-    if (missing.length > 0) {
-        configLink = generateConfigLink(missing, toolName) || undefined;
-        if (configLink) {
-            console.log(`\n🔧 Missing environment variables: ${missing.join(", ")}`);
-            console.log(`📋 Configure them here: ${configLink}\n`);
-        }
-        else {
-            console.log(`\n⚠️  Missing required environment variables: ${missing.join(", ")}`);
-            console.log(`💡 Set them using the 'enact env set' command or your system environment\n`);
-        }
-    }
-    return { resolved, missing, configLink };
-}
-/**
- * Get available environment variables for a package namespace
- */
-export async function getPackageEnvironmentVariables(packageNamespace) {
-    const packageConfig = await readPackageEnvConfig(packageNamespace);
-    const packageVars = {};
-    // Process package variables
-    for (const [name, envVar] of Object.entries(packageConfig.variables)) {
-        packageVars[name] = {
-            value: envVar.encrypted ? "[encrypted]" : envVar.value,
-            encrypted: envVar.encrypted || false,
-            description: envVar.description,
-        };
-    }
-    // System environment variables (filtered to avoid exposing sensitive data)
-    const system = Object.fromEntries(Object.entries(process.env)
-        .filter(([key]) => 
-    // Only include environment variables that look like they might be relevant for tools
-    key.includes("API") ||
-        key.includes("TOKEN") ||
-        key.includes("KEY") ||
-        key.includes("URL") ||
-        key.includes("HOST") ||
-        key.includes("PORT") ||
-        key.startsWith("ENACT_") ||
-        key.startsWith("NODE_") ||
-        key.startsWith("NPM_"))
-        .map(([key, value]) => [key, value || ""]));
-    return { package: packageVars, system };
-}
-/**
- * Validate that all required environment variables are available
- * Following the Enact protocol format for environment variables
- */
-export function validateRequiredEnvironmentVariables(toolEnvConfig, availableVars) {
-    const missing = [];
-    const errors = [];
-    if (!toolEnvConfig) {
-        return { valid: true, missing, errors };
-    }
-    for (const [varName, config] of Object.entries(toolEnvConfig)) {
-        if (typeof config === "object" && config !== null) {
-            // Enact protocol: description, source, required are all required fields
-            // default is optional
-            const isRequired = config.required === true;
-            const hasDefault = config.default !== undefined;
-            const description = config.description || "";
-            const source = config.source || "";
-            if (isRequired &&
-                !hasDefault &&
-                (!(varName in availableVars) || availableVars[varName] === "")) {
-                missing.push(varName);
-                const errorMsg = `Required environment variable '${varName}' is not set`;
-                const detailMsg = description ? ` - ${description}` : "";
-                const sourceMsg = source ? ` (source: ${source})` : "";
-                errors.push(`${errorMsg}${detailMsg}${sourceMsg}`);
-            }
-        }
-    }
-    return {
-        valid: missing.length === 0,
-        missing,
-        errors,
-    };
-}
-// Export the package namespace extraction function for use in other modules
-export { extractPackageNamespace };
-// Load .env file if it exists
-loadDotenv();
-/**
- * Get the web server URL if it's running
- */
-export function getWebServerUrl() {
-    // For now, default to localhost:5555 as that's the standard port
-    // When running via MCP (npx -p @enactprotocol/cli enact-mcp), the web server is automatically started
-    // TODO: In the future, we could check if the server is actually responding or get the port dynamically
-    return "http://localhost:5555";
-}
-/**
- * Generate a configuration link for missing environment variables
- */
-export function generateConfigLink(missingVars, toolName) {
-    const webUrl = getWebServerUrl();
-    if (!webUrl) {
-        return null;
-    }
-    // Extract package namespace from tool name (exclude tool name itself)
-    const packageNamespace = extractPackageNamespace(toolName);
-    const encodedVars = encodeURIComponent(JSON.stringify(missingVars));
-    const encodedPackage = encodeURIComponent(packageNamespace);
-    return `${webUrl}/?vars=${encodedVars}&package=${encodedPackage}`;
-}

package/dist/utils/help.d.ts

@@ -1,36 +0,0 @@
-/**
- * Show the main help message
- */
-export declare function showHelp(): void;
-/**
- * Show version information
- */
-export declare function showVersion(): void;
-/**
- * Show help for the auth command
- */
-export declare function showAuthHelp(): void;
-/**
- * Show help for the init command
- */
-export declare function showInitHelp(): void;
-/**
- * Show help for the publish command
- */
-export declare function showPublishHelp(): void;
-/**
- * Show help for the search command
- */
-export declare function showSearchHelp(): void;
-/**
- * Show help for the remote command
- */
-export declare function showRemoteHelp(): void;
-/**
- * Show help for the user command
- */
-export declare function showUserHelp(): void;
-/**
- * Show help for the env command
- */
-export declare function showEnvHelp(): void;

package/dist/utils/help.js

@@ -1,248 +0,0 @@
-// src/utils/help.ts
-import pc from "picocolors";
-import { readFileSync } from "fs";
-import { join } from "path";
-/**
- * Get the package version from package.json
- */
-function getVersion() {
-    try {
-        const packageJsonPath = join(__dirname, "../../package.json");
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-        return packageJson.version || "0.1.0";
-    }
-    catch (error) {
-        // Fallback version if package.json can't be read
-        return "0.1.0";
-    }
-}
-/**
- * Show the main help message
- */
-export function showHelp() {
-    const version = getVersion();
-    console.error(`
-${pc.bold("Enact CLI")} ${pc.dim(`v${version}`)}
-${pc.dim("A CLI tool for managing and publishing Enact tools")}
-
-${pc.bold("Usage:")}
-  ${pc.cyan("enact")} ${pc.green("<command>")} [options]
-
-${pc.bold("Commands:")}
-  ${pc.green("auth")}       Manage authentication (login, logout, status, token)
-  ${pc.green("env")}        Manage environment variables (set, get, list, delete)
-  ${pc.green("exec")}       Execute a tool by fetching and running it
-  ${pc.green("init")}       Create a new tool definition
-  ${pc.green("mcp")}        MCP client integration (install, list, status)
-  ${pc.green("publish")}    Publish a tool to the registry
-  ${pc.green("search")}     Search for tools in the registry
-  ${pc.green("sign")}       Sign and verify tools with cryptographic signatures
-  ${pc.green("remote")}     Manage remote servers (add, list, remove)
-  ${pc.green("user")}       User operations (get public key)
-
-${pc.bold("Global Options:")}
-  ${pc.yellow("--help, -h")}     Show help message
-  ${pc.yellow("--version, -v")}  Show version information
-
-${pc.bold("Examples:")}
-  ${pc.cyan("enact")}                           ${pc.dim("# Interactive mode")}
-  ${pc.cyan("enact")} ${pc.green("search")} ${pc.yellow("--tags")} web,api         ${pc.dim("# Search tools by tags")}
-  ${pc.cyan("enact")} ${pc.green("exec")} enact/text/slugify      ${pc.dim("# Execute a tool")}
-  ${pc.cyan("enact")} ${pc.green("mcp")} install ${pc.yellow("--client")} claude-desktop ${pc.dim("# Install MCP server")}
-  ${pc.cyan("enact")} ${pc.green("mcp")} install ${pc.yellow("--client")} goose       ${pc.dim("# Install for Goose AI")}
-  ${pc.cyan("enact")} ${pc.green("env")} set API_KEY --encrypt   ${pc.dim("# Set encrypted env var")}
-  ${pc.cyan("enact")} ${pc.green("sign")} verify my-tool.yaml     ${pc.dim("# Verify tool signatures")}
-  ${pc.cyan("enact")} ${pc.green("publish")} my-tool.yaml           ${pc.dim("# Publish a tool")}
-  ${pc.cyan("enact")} ${pc.green("auth")} login                   ${pc.dim("# Login with OAuth")}
-  ${pc.cyan("enact")} ${pc.green("init")} ${pc.yellow("--minimal")}               ${pc.dim("# Create minimal tool template")}
-
-${pc.bold("More Help:")}
-  ${pc.cyan("enact")} ${pc.green("<command>")} ${pc.yellow("--help")}          ${pc.dim("# Show command-specific help")}
-`);
-}
-/**
- * Show version information
- */
-export function showVersion() {
-    const version = getVersion();
-    console.error(`@enactprotocol/cli v${version}`);
-}
-/**
- * Show help for the auth command
- */
-export function showAuthHelp() {
-    console.error(`
-${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("auth")} ${pc.blue("<subcommand>")} [options]
-
-${pc.bold("Manage authentication for Enact registry")}
-
-${pc.bold("Subcommands:")}
-  ${pc.blue("login")}       Login using OAuth
-  ${pc.blue("logout")}      Logout and clear stored credentials
-  ${pc.blue("status")}      Check authentication status
-  ${pc.blue("token")}       Display current authentication token
-
-${pc.bold("Options:")}
-  ${pc.yellow("--help, -h")}     Show this help message
-  ${pc.yellow("--server, -s")}   Specify server URL
-  ${pc.yellow("--port, -p")}     Specify port for OAuth callback
-
-${pc.bold("Examples:")}
-  ${pc.cyan("enact")} ${pc.green("auth")} ${pc.blue("login")}
-  ${pc.cyan("enact")} ${pc.green("auth")} ${pc.blue("status")}
-  ${pc.cyan("enact")} ${pc.green("auth")} ${pc.blue("login")} ${pc.yellow("--server")} https://api.example.com
-`);
-}
-/**
- * Show help for the init command
- */
-export function showInitHelp() {
-    console.error(`
-${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("init")} [options] [name]
-
-${pc.bold("Create a new tool definition file")}
-
-${pc.bold("Arguments:")}
-  ${pc.blue("name")}         Name for the new tool (optional)
-
-${pc.bold("Options:")}
-  ${pc.yellow("--help, -h")}     Show this help message
-  ${pc.yellow("--minimal, -m")}  Create a minimal tool template
-
-${pc.bold("Examples:")}
-  ${pc.cyan("enact")} ${pc.green("init")}
-  ${pc.cyan("enact")} ${pc.green("init")} my-awesome-tool
-  ${pc.cyan("enact")} ${pc.green("init")} ${pc.yellow("--minimal")} simple-tool
-`);
-}
-/**
- * Show help for the publish command
- */
-export function showPublishHelp() {
-    console.error(`
-${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("publish")} [options] [file]
-
-${pc.bold("Publish a tool to the Enact registry")}
-
-${pc.bold("Arguments:")}
-  ${pc.blue("file")}         The tool definition file to publish (YAML format)
-
-${pc.bold("Options:")}
-  ${pc.yellow("--help, -h")}     Show this help message
-  ${pc.yellow("--url")}          Specify the registry URL
-  ${pc.yellow("--token, -t")}    Specify authentication token
-
-${pc.bold("Examples:")}
-  ${pc.cyan("enact")} ${pc.green("publish")} my-tool.yaml
-  ${pc.cyan("enact")} ${pc.green("publish")} ${pc.yellow("--url")} https://registry.example.com my-tool.yaml
-  ${pc.cyan("enact")} ${pc.green("publish")} ${pc.yellow("--token")} abc123 my-tool.yaml
-`);
-}
-/**
- * Show help for the search command
- */
-export function showSearchHelp() {
-    console.error(`
-${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("search")} [options] [query]
-
-${pc.bold("Search for tools in the Enact registry")}
-
-${pc.bold("Arguments:")}
-  ${pc.blue("query")}        Search query (optional)
-
-${pc.bold("Options:")}
-  ${pc.yellow("--help, -h")}     Show this help message
-  ${pc.yellow("--limit, -l")}    Limit number of results (default: 20)
-  ${pc.yellow("--tags")}         Filter by tags (comma-separated)
-  ${pc.yellow("--author, -a")}   Filter by author
-  ${pc.yellow("--format, -f")}   Output format (table, json, minimal)
-
-${pc.bold("Examples:")}
-  ${pc.cyan("enact")} ${pc.green("search")}
-  ${pc.cyan("enact")} ${pc.green("search")} "web scraper"
-  ${pc.cyan("enact")} ${pc.green("search")} ${pc.yellow("--tags")} web,api ${pc.yellow("--limit")} 10
-  ${pc.cyan("enact")} ${pc.green("search")} ${pc.yellow("--author")} johndoe ${pc.yellow("--format")} json
-`);
-}
-/**
- * Show help for the remote command
- */
-export function showRemoteHelp() {
-    console.error(`
-${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("remote")} ${pc.blue("<subcommand>")} [options]
-
-${pc.bold("Manage remote Enact registry servers")}
-
-${pc.bold("Subcommands:")}
-  ${pc.blue("add")}         Add a new remote server
-  ${pc.blue("list")}        List all configured remote servers
-  ${pc.blue("remove")}      Remove a remote server
-
-${pc.bold("Options:")}
-  ${pc.yellow("--help, -h")}     Show this help message
-
-${pc.bold("Examples:")}
-  ${pc.cyan("enact")} ${pc.green("remote")} ${pc.blue("add")}
-  ${pc.cyan("enact")} ${pc.green("remote")} ${pc.blue("list")}
-  ${pc.cyan("enact")} ${pc.green("remote")} ${pc.blue("remove")} origin
-`);
-}
-/**
- * Show help for the user command
- */
-export function showUserHelp() {
-    console.error(`
-${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("user")} ${pc.blue("<subcommand>")} [options]
-
-${pc.bold("User operations for Enact registry")}
-
-${pc.bold("Subcommands:")}
-  ${pc.blue("public-key")}  Get user's public key
-
-${pc.bold("Options:")}
-  ${pc.yellow("--help, -h")}     Show this help message
-  ${pc.yellow("--server, -s")}   Specify server URL
-  ${pc.yellow("--token, -t")}    Specify authentication token
-  ${pc.yellow("--format, -f")}   Output format (default, json)
-
-${pc.bold("Examples:")}
-  ${pc.cyan("enact")} ${pc.green("user")} ${pc.blue("public-key")}
-  ${pc.cyan("enact")} ${pc.green("user")} ${pc.blue("public-key")} ${pc.yellow("--format")} json
-  ${pc.cyan("enact")} ${pc.green("user")} ${pc.blue("public-key")} ${pc.yellow("--server")} https://api.example.com
-`);
-}
-/**
- * Show help for the env command
- */
-export function showEnvHelp() {
-    console.error(`
-${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("<subcommand>")} [options]
-
-${pc.bold("Environment variable management for Enact CLI")}
-
-${pc.bold("Subcommands:")}
-  ${pc.blue("set")} ${pc.magenta("<name>")} [value]      Set an environment variable
-  ${pc.blue("get")} ${pc.magenta("<name>")}              Get an environment variable
-  ${pc.blue("list")}                    List all environment variables
-  ${pc.blue("delete")} ${pc.magenta("<name>")}           Delete an environment variable
-  ${pc.blue("copy")} ${pc.magenta("<from>")} ${pc.magenta("<to>")}        Copy variables between scopes
-  ${pc.blue("export")} [format]         Export variables (env|json|yaml)
-  ${pc.blue("clear")}                   Clear all environment variables
-
-${pc.bold("Options:")}
-  ${pc.yellow("--help, -h")}     Show this help message
-  ${pc.yellow("--global")}       Use global scope (default)
-  ${pc.yellow("--project")}      Use project scope
-  ${pc.yellow("--encrypt")}      Encrypt sensitive values
-  ${pc.yellow("--format")}       Output format (table|json)
-  ${pc.yellow("--show")}         Show actual values (default: hidden)
-
-${pc.bold("Examples:")}
-  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("set")} OPENAI_API_KEY ${pc.yellow("--encrypt")}
-  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("set")} DATABASE_URL postgres://... ${pc.yellow("--project")}
-  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("get")} OPENAI_API_KEY ${pc.yellow("--show")}
-  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("list")} ${pc.yellow("--project")} ${pc.yellow("--format")} json
-  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("copy")} global project
-  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("export")} env > .env
-`);
-}

package/dist/utils/index.d.ts

@@ -1,7 +0,0 @@
-export * from './config';
-export * from './env-loader';
-export { showHelp } from './help';
-export * from './logger';
-export * from './silent-monitor';
-export * from './timeout';
-export { showVersion } from './version';

package/dist/utils/index.js

@@ -1,7 +0,0 @@
-export * from './config';
-export * from './env-loader';
-export { showHelp } from './help';
-export * from './logger';
-export * from './silent-monitor';
-export * from './timeout';
-export { showVersion } from './version';

package/dist/utils/logger.d.ts

@@ -1,35 +0,0 @@
-export declare enum LogLevel {
-    DEBUG = 0,
-    INFO = 1,
-    SUCCESS = 2,
-    WARN = 3,
-    ERROR = 4
-}
-/**
- * Sets the current log level
- */
-export declare function setLogLevel(level: LogLevel): void;
-/**
- * Debug log - only shown when log level is DEBUG
- */
-export declare function debug(message: string): void;
-/**
- * Info log - general information
- */
-export declare function info(message: string): void;
-/**
- * Success log - operation completed successfully
- */
-export declare function success(message: string): void;
-/**
- * Warning log - non-critical issues
- */
-export declare function warn(message: string): void;
-/**
- * Error log - critical issues
- */
-export declare function error(message: string, details?: any): void;
-/**
- * Table log - display tabular data
- */
-export declare function table(data: any[], columns?: string[]): void;

package/dist/utils/logger.js

@@ -1,75 +0,0 @@
-// src/utils/logger.ts
-import pc from "picocolors";
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
-    LogLevel[LogLevel["INFO"] = 1] = "INFO";
-    LogLevel[LogLevel["SUCCESS"] = 2] = "SUCCESS";
-    LogLevel[LogLevel["WARN"] = 3] = "WARN";
-    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
-})(LogLevel || (LogLevel = {}));
-// Default log level
-let currentLogLevel = LogLevel.INFO;
-/**
- * Sets the current log level
- */
-export function setLogLevel(level) {
-    currentLogLevel = level;
-}
-/**
- * Debug log - only shown when log level is DEBUG
- */
-export function debug(message) {
-    if (currentLogLevel <= LogLevel.DEBUG) {
-        console.error(pc.dim(`🔍 ${message}`));
-    }
-}
-/**
- * Info log - general information
- */
-export function info(message) {
-    if (currentLogLevel <= LogLevel.INFO) {
-        console.error(pc.blue(`ℹ️ ${message}`));
-    }
-}
-/**
- * Success log - operation completed successfully
- */
-export function success(message) {
-    if (currentLogLevel <= LogLevel.SUCCESS) {
-        console.error(pc.green(`✓ ${message}`));
-    }
-}
-/**
- * Warning log - non-critical issues
- */
-export function warn(message) {
-    if (currentLogLevel <= LogLevel.WARN) {
-        console.error(pc.yellow(`⚠️ ${message}`));
-    }
-}
-/**
- * Error log - critical issues
- */
-export function error(message, details) {
-    if (currentLogLevel <= LogLevel.ERROR) {
-        console.error(pc.red(`✗ Error: ${message}`));
-        if (details && currentLogLevel === LogLevel.DEBUG) {
-            console.error(pc.dim("Details:"));
-            console.error(details);
-        }
-    }
-}
-/**
- * Table log - display tabular data
- */
-export function table(data, columns) {
-    if (currentLogLevel <= LogLevel.INFO) {
-        if (columns) {
-            console.table(data, columns);
-        }
-        else {
-            console.table(data);
-        }
-    }
-}