modality-kit 0.0.2 → 0.0.3

package/dist/index.js

@@ -56,12 +56,23 @@ function formatErrorResponse(errorData, operation, meta) {
 }
 // src/util_logger.ts
 class ModalityLogger {
-  options;
-  logLevel;
-  constructor(options = {}, logLevel = "info") {
-    this.options = options;
+  static instance;
+  options = {};
+  logLevel = "info";
+  constructor(logOption, logLevel = "info") {
+    if (typeof logOption === "string") {
+      this.options.name = logOption;
+    } else {
+      this.options = { ...this.options, ...logOption };
+    }
     this.logLevel = logLevel;
   }
+  static getInstance(logOption, logLevel) {
+    if (!ModalityLogger.instance) {
+      ModalityLogger.instance = new ModalityLogger(logOption, logLevel);
+    }
+    return ModalityLogger.instance;
+  }
   getTimestamp() {
     if (this.options.timestampFormat === false)
       return;
@@ -74,18 +85,11 @@ class ModalityLogger {
     const levels = ["debug", "info", "warn", "error", "success"];
     return levels.indexOf(level) >= levels.indexOf(this.logLevel);
   }
-  format(level, message, context = {}, extra) {
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  format(level, payload, categroy) {
     const timestamp = this.getTimestamp();
-    const ctx = { ...this.options.context || {}, ...context };
-    const base = {
-      level,
-      message,
-      ...timestamp ? { timestamp } : {},
-      ...Object.keys(ctx).length ? { context: ctx } : {},
-      ...extra ? { ...extra } : {}
-    };
-    if (this.options.json)
-      return JSON.stringify(base);
     let prefix = "";
     switch (level) {
       case "debug":
@@ -106,66 +110,66 @@ class ModalityLogger {
       default:
         prefix = "";
     }
-    let out = `${prefix} ${message}`;
-    if (timestamp)
-      out = `[${timestamp}] ` + out;
-    if (Object.keys(ctx).length)
-      out += ` | context: ${JSON.stringify(ctx)}`;
-    return extra ? [out, extra] : [out];
-  }
-  withContext(context) {
-    return new ModalityLogger({ ...this.options, context: { ...this.options.context || {}, ...context } }, this.logLevel);
-  }
-  setLogLevel(level) {
-    this.logLevel = level;
-  }
-  setOptions(options) {
-    this.options = { ...this.options, ...options };
+    if (timestamp) {
+      prefix += ` [${timestamp}]`;
+    }
+    if (categroy) {
+      prefix += ` [${categroy}]`;
+    }
+    return [prefix, payload];
   }
-  log(level, message, context = {}, extra) {
+  log(level, payload, categroy) {
     if (!this.shouldLog(level))
       return;
-    const formatted = this.format(level, message, context, extra);
+    const formatted = this.format(level, payload, categroy);
     switch (level) {
       case "debug":
-        this.options.json ? console.debug(formatted) : console.debug(...formatted);
+        console.debug(formatted);
         break;
       case "info":
-        this.options.json ? console.info(formatted) : console.info(...formatted);
+        console.info(formatted);
         break;
       case "warn":
-        this.options.json ? console.warn(formatted) : console.warn(...formatted);
+        console.warn(formatted);
         break;
       case "error":
-        this.options.json ? console.error(formatted) : console.error(...formatted);
+        console.error(formatted);
         break;
       case "success":
-        this.options.json ? console.log(formatted) : console.log(...formatted);
+        console.log(formatted);
         break;
       default:
-        this.options.json ? console.log(formatted) : console.log(...formatted);
+        console.log(formatted);
+        break;
     }
   }
-  debug(message, context, error) {
-    const extra = error ? { error: error.message, stack: error.stack } : undefined;
-    this.log("debug", message, context, extra);
+  debug(message, error) {
+    this.log("debug", { message, error });
   }
-  info(message, context) {
-    this.log("info", message, context);
+  info(message, data) {
+    this.log("info", { message, data });
   }
-  warn(message, context) {
-    this.log("warn", message, context);
+  warn(message, resolution) {
+    this.log("warn", { message, resolution });
   }
-  error(message, context, error) {
-    const extra = error ? { error: error.message, stack: error.stack } : undefined;
-    this.log("error", message, context, extra);
+  error(message, error) {
+    const data = { message };
+    if (error) {
+      data.error = {
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    this.log("error", data);
   }
-  success(message, context) {
-    this.log("success", message, context);
+  success(message, data) {
+    this.log("success", { message, data });
   }
 }
+var loggerInstance = ModalityLogger.getInstance.bind(ModalityLogger);
 export {
   setupAITools,
+  loggerInstance,
   formatSuccessResponse,
   formatErrorResponse,
   ModalityLogger

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
 export { setupAITools } from "./util_mcp_tools_converter";
 export type { AITools, AITool } from "./schemas/schemas_tool_config";
 export { formatErrorResponse, formatSuccessResponse } from "./util_response";
-export { ModalityLogger } from "./util_logger";
+export { ModalityLogger, loggerInstance } from "./util_logger";

package/dist/types/util_logger.d.ts

@@ -2,27 +2,26 @@
  * Storage Logger for structured logging
  * Provides consistent logging across storage operations with configurable levels
  */
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'success';
+export type LogLevel = "debug" | "info" | "warn" | "error" | "success";
 export interface LoggerOptions {
-    timestampFormat?: 'iso' | 'locale' | false;
-    color?: boolean;
-    json?: boolean;
-    context?: Record<string, any>;
+    timestampFormat?: "iso" | "locale" | false;
+    name?: string;
 }
 export declare class ModalityLogger {
+    private static instance;
     private options;
     private logLevel;
-    constructor(options?: LoggerOptions, logLevel?: LogLevel);
+    constructor(logOption: string | LoggerOptions, logLevel?: LogLevel);
+    static getInstance(logOption: string | LoggerOptions, logLevel?: LogLevel): ModalityLogger;
     private getTimestamp;
     private shouldLog;
-    private format;
-    withContext(context: Record<string, any>): ModalityLogger;
     setLogLevel(level: LogLevel): void;
-    setOptions(options: LoggerOptions): void;
-    log(level: LogLevel, message: string, context?: Record<string, any>, extra?: any): void;
-    debug(message: string, context?: Record<string, any>, error?: Error): void;
-    info(message: string, context?: Record<string, any>): void;
-    warn(message: string, context?: Record<string, any>): void;
-    error(message: string, context?: Record<string, any>, error?: Error): void;
-    success(message: string, context?: Record<string, any>): void;
+    private format;
+    log(level: LogLevel, payload: any, categroy?: string): void;
+    debug(message: string, error?: Error): void;
+    info(message: string, data?: any): void;
+    warn(message: string, resolution: string): void;
+    error(message: string, error?: Error): void;
+    success(message: string, data?: any): void;
 }
+export declare const loggerInstance: typeof ModalityLogger.getInstance;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.2",
+  "version": "0.0.3",
   "name": "modality-kit",
   "repository": {
     "type": "git",