@invect/core 0.0.1

package/dist/utils/logger.cjs

@@ -0,0 +1,285 @@
+//#region src/utils/logger.ts
+/**
+* Predefined log scopes for Invect feature areas.
+* Use these when creating scoped loggers for consistent naming.
+*/
+const LogScope = {
+	EXECUTION: "execution",
+	VALIDATION: "validation",
+	BATCH: "batch",
+	DATABASE: "database",
+	NODE: "node",
+	GRAPH: "graph",
+	CREDENTIALS: "credentials",
+	AI: "ai",
+	TEMPLATE: "template",
+	RENDERER: "renderer",
+	FLOWS: "flows",
+	VERSIONS: "versions",
+	HTTP: "http"
+};
+const LOG_LEVELS = {
+	silent: -1,
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+const LOG_COLORS = {
+	debug: "\x1B[36m",
+	info: "\x1B[32m",
+	warn: "\x1B[33m",
+	error: "\x1B[31m",
+	silent: "\x1B[0m"
+};
+const SCOPE_COLORS = {
+	execution: "\x1B[35m",
+	validation: "\x1B[33m",
+	batch: "\x1B[36m",
+	database: "\x1B[34m",
+	node: "\x1B[32m",
+	graph: "\x1B[35m",
+	credentials: "\x1B[31m",
+	ai: "\x1B[36m",
+	template: "\x1B[33m",
+	renderer: "\x1B[34m",
+	flows: "\x1B[32m",
+	versions: "\x1B[35m",
+	http: "\x1B[36m"
+};
+const RESET_COLOR = "\x1B[0m";
+const DIM_COLOR = "\x1B[2m";
+/**
+* Enhanced logger that respects log level configuration
+*/
+var BaseLogger = class {
+	logLevel;
+	context;
+	constructor(config, context) {
+		this.logLevel = config.level === "silent" ? "silent" : config.level;
+		this.context = context;
+	}
+	shouldLog(level) {
+		return LOG_LEVELS[level] >= LOG_LEVELS[this.logLevel];
+	}
+	formatMessage(level, message, meta) {
+		const now = /* @__PURE__ */ new Date();
+		const timestamp = now.toTimeString().split(" ")[0] + "." + now.getMilliseconds().toString().padStart(3, "0");
+		const contextStr = this.context ? `[${this.context}]` : "";
+		return `${timestamp} | ${`${LOG_COLORS[level]}${level.toUpperCase().padEnd(6)}${RESET_COLOR}`}|${contextStr} ${message}${meta ? ` ${JSON.stringify(meta, null, 2)}` : ""}`;
+	}
+	debug(message, meta) {
+		if (this.shouldLog("debug")) console.debug(this.formatMessage("debug", message, meta));
+	}
+	info(message, meta) {
+		if (this.shouldLog("info")) console.info(this.formatMessage("info", message, meta));
+	}
+	warn(message, meta) {
+		if (this.shouldLog("warn")) console.warn(this.formatMessage("warn", message, meta));
+	}
+	error(message, error, meta) {
+		if (this.shouldLog("error")) {
+			let errorStr;
+			if (error instanceof Error) errorStr = error.stack || error.message;
+			else if (typeof error === "object" && error !== null) {
+				const maybeStack = Object.prototype.hasOwnProperty.call(error, "stack") && typeof error["stack"] === "string" ? error["stack"] : void 0;
+				const maybeMessage = Object.prototype.hasOwnProperty.call(error, "message") && typeof error["message"] === "string" ? error["message"] : void 0;
+				if (maybeStack) errorStr = maybeStack;
+				else if (maybeMessage) errorStr = maybeMessage;
+				else try {
+					errorStr = error;
+				} catch {
+					errorStr = String(error);
+				}
+			} else if (typeof error === "string") errorStr = error;
+			else if (typeof error === "undefined") errorStr = "undefined";
+			else errorStr = String(error);
+			console.error(this.formatMessage("error", message, { error: errorStr }), meta);
+		}
+	}
+};
+/**
+* Scoped logger that supports independent log levels per scope/feature area.
+*
+* @example
+* ```typescript
+* const loggerManager = new LoggerManager({
+*   level: 'info',
+*   scopes: {
+*     execution: 'debug',  // Verbose logging for execution
+*     validation: 'warn',  // Only warnings for validation
+*     batch: 'silent',     // Disable batch logging
+*   }
+* });
+*
+* const executionLogger = loggerManager.getLogger('execution');
+* executionLogger.debug('Starting flow execution'); // This will log
+*
+* const validationLogger = loggerManager.getLogger('validation');
+* validationLogger.debug('Validating flow'); // This will NOT log (below warn)
+* ```
+*/
+var ScopedLogger = class ScopedLogger {
+	constructor(scope, effectiveLevel, context) {
+		this.scope = scope;
+		this.effectiveLevel = effectiveLevel;
+		this.context = context;
+	}
+	shouldLog(level) {
+		return LOG_LEVELS[level] >= LOG_LEVELS[this.effectiveLevel];
+	}
+	formatMessage(level, message, meta) {
+		const now = /* @__PURE__ */ new Date();
+		const timestamp = now.toTimeString().split(" ")[0] + "." + now.getMilliseconds().toString().padStart(3, "0");
+		const scopeStr = `${SCOPE_COLORS[this.scope] || "\x1B[37m"}[${this.scope}]${RESET_COLOR}`;
+		const contextStr = this.context ? `${DIM_COLOR}(${this.context})${RESET_COLOR}` : "";
+		return `${timestamp} | ${`${LOG_COLORS[level]}${level.toUpperCase().padEnd(6)}${RESET_COLOR}`}| ${scopeStr}${contextStr} ${message}${meta ? ` ${JSON.stringify(meta, null, 2)}` : ""}`;
+	}
+	debug(message, meta) {
+		if (this.shouldLog("debug")) console.debug(this.formatMessage("debug", message, meta));
+	}
+	info(message, meta) {
+		if (this.shouldLog("info")) console.info(this.formatMessage("info", message, meta));
+	}
+	warn(message, meta) {
+		if (this.shouldLog("warn")) console.warn(this.formatMessage("warn", message, meta));
+	}
+	error(message, error, meta) {
+		if (this.shouldLog("error")) {
+			let errorStr;
+			if (error instanceof Error) errorStr = error.stack || error.message;
+			else if (typeof error === "object" && error !== null) {
+				const maybeStack = Object.prototype.hasOwnProperty.call(error, "stack") && typeof error["stack"] === "string" ? error["stack"] : void 0;
+				const maybeMessage = Object.prototype.hasOwnProperty.call(error, "message") && typeof error["message"] === "string" ? error["message"] : void 0;
+				if (maybeStack) errorStr = maybeStack;
+				else if (maybeMessage) errorStr = maybeMessage;
+				else try {
+					errorStr = error;
+				} catch {
+					errorStr = String(error);
+				}
+			} else if (typeof error === "string") errorStr = error;
+			else if (typeof error === "undefined") errorStr = "undefined";
+			else errorStr = String(error);
+			console.error(this.formatMessage("error", message, { error: errorStr }), meta);
+		}
+	}
+	/**
+	* Create a child logger with additional context
+	*/
+	child(context) {
+		const fullContext = this.context ? `${this.context}:${context}` : context;
+		return new ScopedLogger(this.scope, this.effectiveLevel, fullContext);
+	}
+	/**
+	* Get the current scope name
+	*/
+	getScope() {
+		return this.scope;
+	}
+	/**
+	* Get the effective log level for this logger
+	*/
+	getLevel() {
+		return this.effectiveLevel;
+	}
+};
+/**
+* Logger manager that creates and manages scoped loggers with independent log levels.
+*
+* This allows different feature areas of Invect to have different log levels,
+* making it easier to debug specific functionality without noise from other areas.
+*
+* @example
+* ```typescript
+* // In Invect config:
+* const config: InvectConfig = {
+*   logging: {
+*     level: 'info',  // Default level
+*     scopes: {
+*       execution: 'debug',   // Verbose execution logs
+*       validation: 'warn',   // Only validation warnings
+*       batch: 'silent',      // No batch processing logs
+*       database: 'error',    // Only database errors
+*     }
+*   }
+* };
+*
+* // Usage in services:
+* class FlowOrchestrationService {
+*   private readonly logger: ScopedLogger;
+*
+*   constructor(loggerManager: LoggerManager) {
+*     this.logger = loggerManager.getLogger('execution');
+*   }
+* }
+* ```
+*/
+var LoggerManager = class {
+	defaultLevel;
+	scopeLevels;
+	loggerCache;
+	constructor(config) {
+		this.defaultLevel = config.level || "info";
+		this.scopeLevels = new Map(Object.entries(config.scopes || {}));
+		this.loggerCache = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Get a scoped logger for a specific feature area
+	*
+	* @param scope - The scope/feature area name (use LogScope constants for consistency)
+	* @param context - Optional additional context (e.g., class name, method name)
+	* @returns A ScopedLogger instance with the appropriate log level
+	*/
+	getLogger(scope, context) {
+		const cacheKey = context ? `${scope}:${context}` : scope;
+		if (!this.loggerCache.has(cacheKey)) {
+			const logger = new ScopedLogger(scope, this.scopeLevels.get(scope) ?? this.defaultLevel, context);
+			this.loggerCache.set(cacheKey, logger);
+		}
+		return this.loggerCache.get(cacheKey);
+	}
+	/**
+	* Get a basic logger (no scope) for backward compatibility
+	*/
+	getBasicLogger(context) {
+		return new BaseLogger({ level: this.defaultLevel }, context);
+	}
+	/**
+	* Update the log level for a specific scope at runtime
+	*/
+	setLogLevel(scope, level) {
+		this.scopeLevels.set(scope, level);
+		for (const key of this.loggerCache.keys()) if (key === scope || key.startsWith(`${scope}:`)) this.loggerCache.delete(key);
+	}
+	/**
+	* Update the default log level at runtime
+	*/
+	setDefaultLevel(level) {
+		this.defaultLevel = level;
+		this.loggerCache.clear();
+	}
+	/**
+	* Get current configuration for all scopes
+	*/
+	getConfig() {
+		return {
+			defaultLevel: this.defaultLevel,
+			scopes: Object.fromEntries(this.scopeLevels)
+		};
+	}
+	/**
+	* Check if a scope would log at a given level
+	*/
+	wouldLog(scope, level) {
+		const effectiveLevel = this.scopeLevels.get(scope) ?? this.defaultLevel;
+		return LOG_LEVELS[level] >= LOG_LEVELS[effectiveLevel];
+	}
+};
+//#endregion
+exports.BaseLogger = BaseLogger;
+exports.LogScope = LogScope;
+exports.LoggerManager = LoggerManager;
+exports.ScopedLogger = ScopedLogger;
+
+//# sourceMappingURL=logger.cjs.map

package/dist/utils/logger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.cjs","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport { Logger, LoggingConfig } from 'src/types/schemas';\n\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';\n\n/**\n * Predefined log scopes for Invect feature areas.\n * Use these when creating scoped loggers for consistent naming.\n */\nexport const LogScope = {\n  /** Flow execution orchestration */\n  EXECUTION: 'execution',\n  /** Flow validation */\n  VALIDATION: 'validation',\n  /** Batch processing (AI providers) */\n  BATCH: 'batch',\n  /** Database operations */\n  DATABASE: 'database',\n  /** Node execution */\n  NODE: 'node',\n  /** Graph operations (topological sort, etc.) */\n  GRAPH: 'graph',\n  /** Credential management */\n  CREDENTIALS: 'credentials',\n  /** AI/LLM operations */\n  AI: 'ai',\n  /** Template rendering */\n  TEMPLATE: 'template',\n  /** React Flow rendering */\n  RENDERER: 'renderer',\n  /** Flow management (CRUD) */\n  FLOWS: 'flows',\n  /** Flow version management */\n  VERSIONS: 'versions',\n  /** HTTP/API layer */\n  HTTP: 'http',\n} as const;\n\nexport type LogScopeName = (typeof LogScope)[keyof typeof LogScope] | string;\n\n/**\n * Configuration for scope-specific log levels\n */\nexport interface ScopedLoggingConfig extends LoggingConfig {\n  /** Per-scope log level overrides */\n  scopes?: Record<string, LogLevel>;\n}\n\nconst LOG_LEVELS: Record<LogLevel, number> = {\n  silent: -1,\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\n// ANSI color codes for log levels\nconst LOG_COLORS: Record<LogLevel, string> = {\n  debug: '\\x1b[36m', // Cyan\n  info: '\\x1b[32m', // Green\n  warn: '\\x1b[33m', // Yellow\n  error: '\\x1b[31m', // Red\n  silent: '\\x1b[0m', // Reset\n};\n\n// Scope colors for visual distinction\nconst SCOPE_COLORS: Record<string, string> = {\n  execution: '\\x1b[35m', // Magenta\n  validation: '\\x1b[33m', // Yellow\n  batch: '\\x1b[36m', // Cyan\n  database: '\\x1b[34m', // Blue\n  node: '\\x1b[32m', // Green\n  graph: '\\x1b[35m', // Magenta\n  credentials: '\\x1b[31m', // Red\n  ai: '\\x1b[36m', // Cyan\n  template: '\\x1b[33m', // Yellow\n  renderer: '\\x1b[34m', // Blue\n  flows: '\\x1b[32m', // Green\n  versions: '\\x1b[35m', // Magenta\n  http: '\\x1b[36m', // Cyan\n};\n\nconst RESET_COLOR = '\\x1b[0m';\nconst DIM_COLOR = '\\x1b[2m';\n\n/**\n * Enhanced logger that respects log level configuration\n */\nexport class BaseLogger implements Logger {\n  private readonly logLevel: LogLevel;\n  private readonly context?: string;\n\n  constructor(config: LoggingConfig, context?: string) {\n    this.logLevel = config.level === 'silent' ? 'silent' : config.level;\n    this.context = context;\n  }\n\n  private shouldLog(level: LogLevel): boolean {\n    return LOG_LEVELS[level] >= LOG_LEVELS[this.logLevel];\n  }\n\n  private formatMessage(level: LogLevel, message: string, meta?: unknown): string {\n    const now = new Date();\n    const timestamp =\n      now.toTimeString().split(' ')[0] + '.' + now.getMilliseconds().toString().padStart(3, '0');\n    const contextStr = this.context ? `[${this.context}]` : '';\n    const color = LOG_COLORS[level];\n    const levelStr = `${color}${level.toUpperCase().padEnd(6)}${RESET_COLOR}`;\n    const metaStr = meta ? ` ${JSON.stringify(meta, null, 2)}` : '';\n\n    return `${timestamp} | ${levelStr}|${contextStr} ${message}${metaStr}`;\n  }\n\n  debug(message: string, meta?: unknown): void {\n    if (this.shouldLog('debug')) {\n      console.debug(this.formatMessage('debug', message, meta));\n    }\n  }\n\n  info(message: string, meta?: unknown): void {\n    if (this.shouldLog('info')) {\n      console.info(this.formatMessage('info', message, meta));\n    }\n  }\n\n  warn(message: string, meta?: unknown): void {\n    if (this.shouldLog('warn')) {\n      console.warn(this.formatMessage('warn', message, meta));\n    }\n  }\n\n  error(message: string, error?: unknown, meta?: unknown): void {\n    if (this.shouldLog('error')) {\n      let errorStr: string | object;\n      if (error instanceof Error) {\n        errorStr = error.stack || error.message;\n      } else if (typeof error === 'object' && error !== null) {\n        // Try to extract message/stack if present, else JSON stringify\n        const maybeStack =\n          Object.prototype.hasOwnProperty.call(error, 'stack') &&\n          typeof (error as Record<string, unknown>)['stack'] === 'string'\n            ? ((error as Record<string, unknown>)['stack'] as string)\n            : undefined;\n        const maybeMessage =\n          Object.prototype.hasOwnProperty.call(error, 'message') &&\n          typeof (error as Record<string, unknown>)['message'] === 'string'\n            ? ((error as Record<string, unknown>)['message'] as string)\n            : undefined;\n        if (maybeStack) {\n          errorStr = maybeStack;\n        } else if (maybeMessage) {\n          errorStr = maybeMessage;\n        } else {\n          try {\n            errorStr = error;\n          } catch {\n            errorStr = String(error);\n          }\n        }\n      } else if (typeof error === 'string') {\n        errorStr = error;\n      } else if (typeof error === 'undefined') {\n        errorStr = 'undefined';\n      } else {\n        errorStr = String(error);\n      }\n      console.error(this.formatMessage('error', message, { error: errorStr }), meta);\n    }\n  }\n}\n\n/**\n * Scoped logger that supports independent log levels per scope/feature area.\n *\n * @example\n * ```typescript\n * const loggerManager = new LoggerManager({\n *   level: 'info',\n *   scopes: {\n *     execution: 'debug',  // Verbose logging for execution\n *     validation: 'warn',  // Only warnings for validation\n *     batch: 'silent',     // Disable batch logging\n *   }\n * });\n *\n * const executionLogger = loggerManager.getLogger('execution');\n * executionLogger.debug('Starting flow execution'); // This will log\n *\n * const validationLogger = loggerManager.getLogger('validation');\n * validationLogger.debug('Validating flow'); // This will NOT log (below warn)\n * ```\n */\nexport class ScopedLogger implements Logger {\n  constructor(\n    private readonly scope: string,\n    private readonly effectiveLevel: LogLevel,\n    private readonly context?: string,\n  ) {}\n\n  private shouldLog(level: LogLevel): boolean {\n    return LOG_LEVELS[level] >= LOG_LEVELS[this.effectiveLevel];\n  }\n\n  private formatMessage(level: LogLevel, message: string, meta?: unknown): string {\n    const now = new Date();\n    const timestamp =\n      now.toTimeString().split(' ')[0] + '.' + now.getMilliseconds().toString().padStart(3, '0');\n\n    // Build scope/context string\n    const scopeColor = SCOPE_COLORS[this.scope] || '\\x1b[37m'; // Default white\n    const scopeStr = `${scopeColor}[${this.scope}]${RESET_COLOR}`;\n    const contextStr = this.context ? `${DIM_COLOR}(${this.context})${RESET_COLOR}` : '';\n\n    const color = LOG_COLORS[level];\n    const levelStr = `${color}${level.toUpperCase().padEnd(6)}${RESET_COLOR}`;\n    const metaStr = meta ? ` ${JSON.stringify(meta, null, 2)}` : '';\n\n    return `${timestamp} | ${levelStr}| ${scopeStr}${contextStr} ${message}${metaStr}`;\n  }\n\n  debug(message: string, meta?: unknown): void {\n    if (this.shouldLog('debug')) {\n      console.debug(this.formatMessage('debug', message, meta));\n    }\n  }\n\n  info(message: string, meta?: unknown): void {\n    if (this.shouldLog('info')) {\n      console.info(this.formatMessage('info', message, meta));\n    }\n  }\n\n  warn(message: string, meta?: unknown): void {\n    if (this.shouldLog('warn')) {\n      console.warn(this.formatMessage('warn', message, meta));\n    }\n  }\n\n  error(message: string, error?: unknown, meta?: unknown): void {\n    if (this.shouldLog('error')) {\n      let errorStr: string | object;\n      if (error instanceof Error) {\n        errorStr = error.stack || error.message;\n      } else if (typeof error === 'object' && error !== null) {\n        const maybeStack =\n          Object.prototype.hasOwnProperty.call(error, 'stack') &&\n          typeof (error as Record<string, unknown>)['stack'] === 'string'\n            ? ((error as Record<string, unknown>)['stack'] as string)\n            : undefined;\n        const maybeMessage =\n          Object.prototype.hasOwnProperty.call(error, 'message') &&\n          typeof (error as Record<string, unknown>)['message'] === 'string'\n            ? ((error as Record<string, unknown>)['message'] as string)\n            : undefined;\n        if (maybeStack) {\n          errorStr = maybeStack;\n        } else if (maybeMessage) {\n          errorStr = maybeMessage;\n        } else {\n          try {\n            errorStr = error;\n          } catch {\n            errorStr = String(error);\n          }\n        }\n      } else if (typeof error === 'string') {\n        errorStr = error;\n      } else if (typeof error === 'undefined') {\n        errorStr = 'undefined';\n      } else {\n        errorStr = String(error);\n      }\n      console.error(this.formatMessage('error', message, { error: errorStr }), meta);\n    }\n  }\n\n  /**\n   * Create a child logger with additional context\n   */\n  child(context: string): ScopedLogger {\n    const fullContext = this.context ? `${this.context}:${context}` : context;\n    return new ScopedLogger(this.scope, this.effectiveLevel, fullContext);\n  }\n\n  /**\n   * Get the current scope name\n   */\n  getScope(): string {\n    return this.scope;\n  }\n\n  /**\n   * Get the effective log level for this logger\n   */\n  getLevel(): LogLevel {\n    return this.effectiveLevel;\n  }\n}\n\n/**\n * Logger manager that creates and manages scoped loggers with independent log levels.\n *\n * This allows different feature areas of Invect to have different log levels,\n * making it easier to debug specific functionality without noise from other areas.\n *\n * @example\n * ```typescript\n * // In Invect config:\n * const config: InvectConfig = {\n *   logging: {\n *     level: 'info',  // Default level\n *     scopes: {\n *       execution: 'debug',   // Verbose execution logs\n *       validation: 'warn',   // Only validation warnings\n *       batch: 'silent',      // No batch processing logs\n *       database: 'error',    // Only database errors\n *     }\n *   }\n * };\n *\n * // Usage in services:\n * class FlowOrchestrationService {\n *   private readonly logger: ScopedLogger;\n *\n *   constructor(loggerManager: LoggerManager) {\n *     this.logger = loggerManager.getLogger('execution');\n *   }\n * }\n * ```\n */\nexport class LoggerManager {\n  private defaultLevel: LogLevel;\n  private readonly scopeLevels: Map<string, LogLevel>;\n  private readonly loggerCache: Map<string, ScopedLogger>;\n\n  constructor(config: ScopedLoggingConfig) {\n    this.defaultLevel = config.level || 'info';\n    this.scopeLevels = new Map(Object.entries(config.scopes || {}));\n    this.loggerCache = new Map();\n  }\n\n  /**\n   * Get a scoped logger for a specific feature area\n   *\n   * @param scope - The scope/feature area name (use LogScope constants for consistency)\n   * @param context - Optional additional context (e.g., class name, method name)\n   * @returns A ScopedLogger instance with the appropriate log level\n   */\n  getLogger(scope: LogScopeName, context?: string): ScopedLogger {\n    const cacheKey = context ? `${scope}:${context}` : scope;\n\n    if (!this.loggerCache.has(cacheKey)) {\n      const effectiveLevel = this.scopeLevels.get(scope) ?? this.defaultLevel;\n      const logger = new ScopedLogger(scope, effectiveLevel, context);\n      this.loggerCache.set(cacheKey, logger);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- just set above\n    return this.loggerCache.get(cacheKey)!;\n  }\n\n  /**\n   * Get a basic logger (no scope) for backward compatibility\n   */\n  getBasicLogger(context?: string): BaseLogger {\n    return new BaseLogger({ level: this.defaultLevel }, context);\n  }\n\n  /**\n   * Update the log level for a specific scope at runtime\n   */\n  setLogLevel(scope: string, level: LogLevel): void {\n    this.scopeLevels.set(scope, level);\n    // Clear cached loggers for this scope so they get recreated with new level\n    for (const key of this.loggerCache.keys()) {\n      if (key === scope || key.startsWith(`${scope}:`)) {\n        this.loggerCache.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Update the default log level at runtime\n   */\n  setDefaultLevel(level: LogLevel): void {\n    this.defaultLevel = level;\n    // Clear all cached loggers\n    this.loggerCache.clear();\n  }\n\n  /**\n   * Get current configuration for all scopes\n   */\n  getConfig(): { defaultLevel: LogLevel; scopes: Record<string, LogLevel> } {\n    return {\n      defaultLevel: this.defaultLevel,\n      scopes: Object.fromEntries(this.scopeLevels),\n    };\n  }\n\n  /**\n   * Check if a scope would log at a given level\n   */\n  wouldLog(scope: string, level: LogLevel): boolean {\n    const effectiveLevel = this.scopeLevels.get(scope) ?? this.defaultLevel;\n    return LOG_LEVELS[level] >= LOG_LEVELS[effectiveLevel];\n  }\n}\n"],"mappings":"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"}

package/dist/utils/logger.d.cts

@@ -0,0 +1,161 @@
+import { Logger, LoggingConfig } from "../types/schemas-fresh/invect-config.cjs";
+
+//#region src/utils/logger.d.ts
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Predefined log scopes for Invect feature areas.
+ * Use these when creating scoped loggers for consistent naming.
+ */
+declare const LogScope: {
+  /** Flow execution orchestration */readonly EXECUTION: "execution"; /** Flow validation */
+  readonly VALIDATION: "validation"; /** Batch processing (AI providers) */
+  readonly BATCH: "batch"; /** Database operations */
+  readonly DATABASE: "database"; /** Node execution */
+  readonly NODE: "node"; /** Graph operations (topological sort, etc.) */
+  readonly GRAPH: "graph"; /** Credential management */
+  readonly CREDENTIALS: "credentials"; /** AI/LLM operations */
+  readonly AI: "ai"; /** Template rendering */
+  readonly TEMPLATE: "template"; /** React Flow rendering */
+  readonly RENDERER: "renderer"; /** Flow management (CRUD) */
+  readonly FLOWS: "flows"; /** Flow version management */
+  readonly VERSIONS: "versions"; /** HTTP/API layer */
+  readonly HTTP: "http";
+};
+type LogScopeName = (typeof LogScope)[keyof typeof LogScope] | string;
+/**
+ * Configuration for scope-specific log levels
+ */
+interface ScopedLoggingConfig extends LoggingConfig {
+  /** Per-scope log level overrides */
+  scopes?: Record<string, LogLevel>;
+}
+/**
+ * Enhanced logger that respects log level configuration
+ */
+declare class BaseLogger implements Logger {
+  private readonly logLevel;
+  private readonly context?;
+  constructor(config: LoggingConfig, context?: string);
+  private shouldLog;
+  private formatMessage;
+  debug(message: string, meta?: unknown): void;
+  info(message: string, meta?: unknown): void;
+  warn(message: string, meta?: unknown): void;
+  error(message: string, error?: unknown, meta?: unknown): void;
+}
+/**
+ * Scoped logger that supports independent log levels per scope/feature area.
+ *
+ * @example
+ * ```typescript
+ * const loggerManager = new LoggerManager({
+ *   level: 'info',
+ *   scopes: {
+ *     execution: 'debug',  // Verbose logging for execution
+ *     validation: 'warn',  // Only warnings for validation
+ *     batch: 'silent',     // Disable batch logging
+ *   }
+ * });
+ *
+ * const executionLogger = loggerManager.getLogger('execution');
+ * executionLogger.debug('Starting flow execution'); // This will log
+ *
+ * const validationLogger = loggerManager.getLogger('validation');
+ * validationLogger.debug('Validating flow'); // This will NOT log (below warn)
+ * ```
+ */
+declare class ScopedLogger implements Logger {
+  private readonly scope;
+  private readonly effectiveLevel;
+  private readonly context?;
+  constructor(scope: string, effectiveLevel: LogLevel, context?: string | undefined);
+  private shouldLog;
+  private formatMessage;
+  debug(message: string, meta?: unknown): void;
+  info(message: string, meta?: unknown): void;
+  warn(message: string, meta?: unknown): void;
+  error(message: string, error?: unknown, meta?: unknown): void;
+  /**
+   * Create a child logger with additional context
+   */
+  child(context: string): ScopedLogger;
+  /**
+   * Get the current scope name
+   */
+  getScope(): string;
+  /**
+   * Get the effective log level for this logger
+   */
+  getLevel(): LogLevel;
+}
+/**
+ * Logger manager that creates and manages scoped loggers with independent log levels.
+ *
+ * This allows different feature areas of Invect to have different log levels,
+ * making it easier to debug specific functionality without noise from other areas.
+ *
+ * @example
+ * ```typescript
+ * // In Invect config:
+ * const config: InvectConfig = {
+ *   logging: {
+ *     level: 'info',  // Default level
+ *     scopes: {
+ *       execution: 'debug',   // Verbose execution logs
+ *       validation: 'warn',   // Only validation warnings
+ *       batch: 'silent',      // No batch processing logs
+ *       database: 'error',    // Only database errors
+ *     }
+ *   }
+ * };
+ *
+ * // Usage in services:
+ * class FlowOrchestrationService {
+ *   private readonly logger: ScopedLogger;
+ *
+ *   constructor(loggerManager: LoggerManager) {
+ *     this.logger = loggerManager.getLogger('execution');
+ *   }
+ * }
+ * ```
+ */
+declare class LoggerManager {
+  private defaultLevel;
+  private readonly scopeLevels;
+  private readonly loggerCache;
+  constructor(config: ScopedLoggingConfig);
+  /**
+   * Get a scoped logger for a specific feature area
+   *
+   * @param scope - The scope/feature area name (use LogScope constants for consistency)
+   * @param context - Optional additional context (e.g., class name, method name)
+   * @returns A ScopedLogger instance with the appropriate log level
+   */
+  getLogger(scope: LogScopeName, context?: string): ScopedLogger;
+  /**
+   * Get a basic logger (no scope) for backward compatibility
+   */
+  getBasicLogger(context?: string): BaseLogger;
+  /**
+   * Update the log level for a specific scope at runtime
+   */
+  setLogLevel(scope: string, level: LogLevel): void;
+  /**
+   * Update the default log level at runtime
+   */
+  setDefaultLevel(level: LogLevel): void;
+  /**
+   * Get current configuration for all scopes
+   */
+  getConfig(): {
+    defaultLevel: LogLevel;
+    scopes: Record<string, LogLevel>;
+  };
+  /**
+   * Check if a scope would log at a given level
+   */
+  wouldLog(scope: string, level: LogLevel): boolean;
+}
+//#endregion
+export { BaseLogger, LogLevel, LogScope, LogScopeName, LoggerManager, ScopedLogger, ScopedLoggingConfig };
+//# sourceMappingURL=logger.d.cts.map

package/dist/utils/logger.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.cts","names":[],"sources":["../../src/utils/logger.ts"],"mappings":";;;KAGY,QAAA;;AAAZ;;;cAMa,QAAA;EANO,oEAiCV;EAAA,mCAAA;EAAA;;;;;;;iCAEE;EAAA;iCAAsD;EAAA;;KAAtD,YAAA,WAAuB,QAAA,eAAuB,QAAA;;;;UAKzC,mBAAA,SAA4B,aAAA;EAAa;EAExD,MAAA,GAAS,MAAA,SAAe,QAAA;AAAA;;;;cA2Cb,UAAA,YAAsB,MAAA;EAAA,iBAChB,QAAA;EAAA,iBACA,OAAA;cAEL,MAAA,EAAQ,aAAA,EAAe,OAAA;EAAA,QAK3B,SAAA;EAAA,QAIA,aAAA;EAYR,KAAA,CAAM,OAAA,UAAiB,IAAA;EAMvB,IAAA,CAAK,OAAA,UAAiB,IAAA;EAMtB,IAAA,CAAK,OAAA,UAAiB,IAAA;EAMtB,KAAA,CAAM,OAAA,UAAiB,KAAA,YAAiB,IAAA;AAAA;;;;;;;;;;;;;;;;;;;AA6D1C;;;cAAa,YAAA,YAAwB,MAAA;EAAA,iBAEhB,KAAA;EAAA,iBACA,cAAA;EAAA,iBACA,OAAA;cAFA,KAAA,UACA,cAAA,EAAgB,QAAA,EAChB,OAAA;EAAA,QAGX,SAAA;EAAA,QAIA,aAAA;EAiBR,KAAA,CAAM,OAAA,UAAiB,IAAA;EAMvB,IAAA,CAAK,OAAA,UAAiB,IAAA;EAMtB,IAAA,CAAK,OAAA,UAAiB,IAAA;EAMtB,KAAA,CAAM,OAAA,UAAiB,KAAA,YAAiB,IAAA;EA5CrB;;;EAqFnB,KAAA,CAAM,OAAA,WAAkB,YAAA;EAhFhB;;;EAwFR,QAAA,CAAA;EAnEuB;;;EA0EvB,QAAA,CAAA,GAAY,QAAA;AAAA;;;;;;;;;;;;;;;AAoCd;;;;;;;;;;;;;;;;;cAAa,aAAA;EAAA,QACH,YAAA;EAAA,iBACS,WAAA;EAAA,iBACA,WAAA;cAEL,MAAA,EAAQ,mBAAA;EAaH;;;;;;;EAAjB,SAAA,CAAU,KAAA,EAAO,YAAA,EAAc,OAAA,YAAmB,YAAA;EAuBtC;;;EAPZ,cAAA,CAAe,OAAA,YAAmB,UAAA;EAoBX;;;EAbvB,WAAA,CAAY,KAAA,UAAe,KAAA,EAAO,QAAA;EAsBL;;;EAT7B,eAAA,CAAgB,KAAA,EAAO,QAAA;EAmBvB;;;EAVA,SAAA,CAAA;IAAe,YAAA,EAAc,QAAA;IAAU,MAAA,EAAQ,MAAA,SAAe,QAAA;EAAA;;;;EAU9D,QAAA,CAAS,KAAA,UAAe,KAAA,EAAO,QAAA;AAAA"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,160 @@
+import { Logger, LoggingConfig } from "../types/schemas-fresh/invect-config.js";
+//#region src/utils/logger.d.ts
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Predefined log scopes for Invect feature areas.
+ * Use these when creating scoped loggers for consistent naming.
+ */
+declare const LogScope: {
+  /** Flow execution orchestration */readonly EXECUTION: "execution"; /** Flow validation */
+  readonly VALIDATION: "validation"; /** Batch processing (AI providers) */
+  readonly BATCH: "batch"; /** Database operations */
+  readonly DATABASE: "database"; /** Node execution */
+  readonly NODE: "node"; /** Graph operations (topological sort, etc.) */
+  readonly GRAPH: "graph"; /** Credential management */
+  readonly CREDENTIALS: "credentials"; /** AI/LLM operations */
+  readonly AI: "ai"; /** Template rendering */
+  readonly TEMPLATE: "template"; /** React Flow rendering */
+  readonly RENDERER: "renderer"; /** Flow management (CRUD) */
+  readonly FLOWS: "flows"; /** Flow version management */
+  readonly VERSIONS: "versions"; /** HTTP/API layer */
+  readonly HTTP: "http";
+};
+type LogScopeName = (typeof LogScope)[keyof typeof LogScope] | string;
+/**
+ * Configuration for scope-specific log levels
+ */
+interface ScopedLoggingConfig extends LoggingConfig {
+  /** Per-scope log level overrides */
+  scopes?: Record<string, LogLevel>;
+}
+/**
+ * Enhanced logger that respects log level configuration
+ */
+declare class BaseLogger implements Logger {
+  private readonly logLevel;
+  private readonly context?;
+  constructor(config: LoggingConfig, context?: string);
+  private shouldLog;
+  private formatMessage;
+  debug(message: string, meta?: unknown): void;
+  info(message: string, meta?: unknown): void;
+  warn(message: string, meta?: unknown): void;
+  error(message: string, error?: unknown, meta?: unknown): void;
+}
+/**
+ * Scoped logger that supports independent log levels per scope/feature area.
+ *
+ * @example
+ * ```typescript
+ * const loggerManager = new LoggerManager({
+ *   level: 'info',
+ *   scopes: {
+ *     execution: 'debug',  // Verbose logging for execution
+ *     validation: 'warn',  // Only warnings for validation
+ *     batch: 'silent',     // Disable batch logging
+ *   }
+ * });
+ *
+ * const executionLogger = loggerManager.getLogger('execution');
+ * executionLogger.debug('Starting flow execution'); // This will log
+ *
+ * const validationLogger = loggerManager.getLogger('validation');
+ * validationLogger.debug('Validating flow'); // This will NOT log (below warn)
+ * ```
+ */
+declare class ScopedLogger implements Logger {
+  private readonly scope;
+  private readonly effectiveLevel;
+  private readonly context?;
+  constructor(scope: string, effectiveLevel: LogLevel, context?: string | undefined);
+  private shouldLog;
+  private formatMessage;
+  debug(message: string, meta?: unknown): void;
+  info(message: string, meta?: unknown): void;
+  warn(message: string, meta?: unknown): void;
+  error(message: string, error?: unknown, meta?: unknown): void;
+  /**
+   * Create a child logger with additional context
+   */
+  child(context: string): ScopedLogger;
+  /**
+   * Get the current scope name
+   */
+  getScope(): string;
+  /**
+   * Get the effective log level for this logger
+   */
+  getLevel(): LogLevel;
+}
+/**
+ * Logger manager that creates and manages scoped loggers with independent log levels.
+ *
+ * This allows different feature areas of Invect to have different log levels,
+ * making it easier to debug specific functionality without noise from other areas.
+ *
+ * @example
+ * ```typescript
+ * // In Invect config:
+ * const config: InvectConfig = {
+ *   logging: {
+ *     level: 'info',  // Default level
+ *     scopes: {
+ *       execution: 'debug',   // Verbose execution logs
+ *       validation: 'warn',   // Only validation warnings
+ *       batch: 'silent',      // No batch processing logs
+ *       database: 'error',    // Only database errors
+ *     }
+ *   }
+ * };
+ *
+ * // Usage in services:
+ * class FlowOrchestrationService {
+ *   private readonly logger: ScopedLogger;
+ *
+ *   constructor(loggerManager: LoggerManager) {
+ *     this.logger = loggerManager.getLogger('execution');
+ *   }
+ * }
+ * ```
+ */
+declare class LoggerManager {
+  private defaultLevel;
+  private readonly scopeLevels;
+  private readonly loggerCache;
+  constructor(config: ScopedLoggingConfig);
+  /**
+   * Get a scoped logger for a specific feature area
+   *
+   * @param scope - The scope/feature area name (use LogScope constants for consistency)
+   * @param context - Optional additional context (e.g., class name, method name)
+   * @returns A ScopedLogger instance with the appropriate log level
+   */
+  getLogger(scope: LogScopeName, context?: string): ScopedLogger;
+  /**
+   * Get a basic logger (no scope) for backward compatibility
+   */
+  getBasicLogger(context?: string): BaseLogger;
+  /**
+   * Update the log level for a specific scope at runtime
+   */
+  setLogLevel(scope: string, level: LogLevel): void;
+  /**
+   * Update the default log level at runtime
+   */
+  setDefaultLevel(level: LogLevel): void;
+  /**
+   * Get current configuration for all scopes
+   */
+  getConfig(): {
+    defaultLevel: LogLevel;
+    scopes: Record<string, LogLevel>;
+  };
+  /**
+   * Check if a scope would log at a given level
+   */
+  wouldLog(scope: string, level: LogLevel): boolean;
+}
+//#endregion
+export { BaseLogger, LogLevel, LogScope, LogScopeName, LoggerManager, ScopedLogger, ScopedLoggingConfig };
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../../src/utils/logger.ts"],"mappings":";;KAGY,QAAA;;;AAAZ;;cAMa,QAAA;EANO,oEAMP;EAAA;;;;;;;;;2BA6BW;EAAA,+BAAW;EAAA;;KAAvB,YAAA,WAAuB,QAAA,eAAuB,QAAA;;;;UAKzC,mBAAA,SAA4B,aAAA;EAAa;EAExD,MAAA,GAAS,MAAA,SAAe,QAAA;AAAA;;;;cA2Cb,UAAA,YAAsB,MAAA;EAAA,iBAChB,QAAA;EAAA,iBACA,OAAA;cAEL,MAAA,EAAQ,aAAA,EAAe,OAAA;EAAA,QAK3B,SAAA;EAAA,QAIA,aAAA;EAYR,KAAA,CAAM,OAAA,UAAiB,IAAA;EAMvB,IAAA,CAAK,OAAA,UAAiB,IAAA;EAMtB,IAAA,CAAK,OAAA,UAAiB,IAAA;EAMtB,KAAA,CAAM,OAAA,UAAiB,KAAA,YAAiB,IAAA;AAAA;;;;;;;;;;;;;;;;;;;;AA6D1C;;cAAa,YAAA,YAAwB,MAAA;EAAA,iBAEhB,KAAA;EAAA,iBACA,cAAA;EAAA,iBACA,OAAA;cAFA,KAAA,UACA,cAAA,EAAgB,QAAA,EAChB,OAAA;EAAA,QAGX,SAAA;EAAA,QAIA,aAAA;EAiBR,KAAA,CAAM,OAAA,UAAiB,IAAA;EAMvB,IAAA,CAAK,OAAA,UAAiB,IAAA;EAMtB,IAAA,CAAK,OAAA,UAAiB,IAAA;EAMtB,KAAA,CAAM,OAAA,UAAiB,KAAA,YAAiB,IAAA;;;;EAyCxC,KAAA,CAAM,OAAA,WAAkB,YAAA;EAnFL;;;EA2FnB,QAAA,CAAA;EAnEM;;;EA0EN,QAAA,CAAA,GAAY,QAAA;AAAA;;;;;;;;;;;;;;;;AAoCd;;;;;;;;;;;;;;;;cAAa,aAAA;EAAA,QACH,YAAA;EAAA,iBACS,WAAA;EAAA,iBACA,WAAA;cAEL,MAAA,EAAQ,mBAAA;EAapB;;;;;;;EAAA,SAAA,CAAU,KAAA,EAAO,YAAA,EAAc,OAAA,YAAmB,YAAA;EAuBlD;;;EAPA,cAAA,CAAe,OAAA,YAAmB,UAAA;EAoBlC;;;EAbA,WAAA,CAAY,KAAA,UAAe,KAAA,EAAO,QAAA;EAsBnB;;;EATf,eAAA,CAAgB,KAAA,EAAO,QAAA;EASuC;;;EAA9D,SAAA,CAAA;IAAe,YAAA,EAAc,QAAA;IAAU,MAAA,EAAQ,MAAA,SAAe,QAAA;EAAA;;;;EAU9D,QAAA,CAAS,KAAA,UAAe,KAAA,EAAO,QAAA;AAAA"}