modality-kit 0.0.1 → 0.0.3

package/dist/index.js

@@ -54,8 +54,123 @@ function formatErrorResponse(errorData, operation, meta) {
   }
   return JSON.stringify(errorResponse);
 }
+// src/util_logger.ts
+class ModalityLogger {
+  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;
+    const now = new Date;
+    if (this.options.timestampFormat === "locale")
+      return now.toLocaleString();
+    return now.toISOString();
+  }
+  shouldLog(level) {
+    const levels = ["debug", "info", "warn", "error", "success"];
+    return levels.indexOf(level) >= levels.indexOf(this.logLevel);
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  format(level, payload, categroy) {
+    const timestamp = this.getTimestamp();
+    let prefix = "";
+    switch (level) {
+      case "debug":
+        prefix = "\uD83D\uDD0D";
+        break;
+      case "info":
+        prefix = "ℹ️";
+        break;
+      case "warn":
+        prefix = "⚠️";
+        break;
+      case "error":
+        prefix = "❌";
+        break;
+      case "success":
+        prefix = "✅";
+        break;
+      default:
+        prefix = "";
+    }
+    if (timestamp) {
+      prefix += ` [${timestamp}]`;
+    }
+    if (categroy) {
+      prefix += ` [${categroy}]`;
+    }
+    return [prefix, payload];
+  }
+  log(level, payload, categroy) {
+    if (!this.shouldLog(level))
+      return;
+    const formatted = this.format(level, payload, categroy);
+    switch (level) {
+      case "debug":
+        console.debug(formatted);
+        break;
+      case "info":
+        console.info(formatted);
+        break;
+      case "warn":
+        console.warn(formatted);
+        break;
+      case "error":
+        console.error(formatted);
+        break;
+      case "success":
+        console.log(formatted);
+        break;
+      default:
+        console.log(formatted);
+        break;
+    }
+  }
+  debug(message, error) {
+    this.log("debug", { message, error });
+  }
+  info(message, data) {
+    this.log("info", { message, data });
+  }
+  warn(message, resolution) {
+    this.log("warn", { message, resolution });
+  }
+  error(message, error) {
+    const data = { message };
+    if (error) {
+      data.error = {
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    this.log("error", data);
+  }
+  success(message, data) {
+    this.log("success", { message, data });
+  }
+}
+var loggerInstance = ModalityLogger.getInstance.bind(ModalityLogger);
 export {
   setupAITools,
+  loggerInstance,
   formatSuccessResponse,
-  formatErrorResponse
+  formatErrorResponse,
+  ModalityLogger
 };

package/dist/types/index.d.ts

@@ -1,3 +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, loggerInstance } from "./util_logger";

package/dist/types/util_logger.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Storage Logger for structured logging
+ * Provides consistent logging across storage operations with configurable levels
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error" | "success";
+export interface LoggerOptions {
+    timestampFormat?: "iso" | "locale" | false;
+    name?: string;
+}
+export declare class ModalityLogger {
+    private static instance;
+    private options;
+    private logLevel;
+    constructor(logOption: string | LoggerOptions, logLevel?: LogLevel);
+    static getInstance(logOption: string | LoggerOptions, logLevel?: LogLevel): ModalityLogger;
+    private getTimestamp;
+    private shouldLog;
+    setLogLevel(level: LogLevel): 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.1",
+  "version": "0.0.3",
   "name": "modality-kit",
   "repository": {
     "type": "git",
@@ -26,9 +26,10 @@
   "main": "./dist/index.js",
   "scripts": {
     "update-compile-sh": "yo reshow:compile-sh",
+    "build:clean": "find ./dist -name '*.*' | xargs rm -rf",
     "build:types": "bunx tsc -p ./",
     "build:src": "bun build src/index.ts --outdir dist",
-    "build": "bun run build:src && bun run build:types",
+    "build": "bun run build:clean && bun run build:src && bun run build:types",
     "test": "npm run build",
     "prepublishOnly": "npm run test"
   },