agentxjs 0.1.1 → 0.1.4

package/dist/index.cjs

@@ -1,9 +1,5 @@
 'use strict';
 
-var common = require('@agentxjs/common');
-var agentx = require('@agentxjs/types/agentx');
-var event = require('@agentxjs/types/event');
-
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -14,6 +10,192 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../common/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  ConsoleLogger: () => exports.ConsoleLogger,
+  LoggerFactoryImpl: () => exports.LoggerFactoryImpl,
+  createLogger: () => createLogger,
+  setLoggerFactory: () => setLoggerFactory
+});
+function setLoggerFactory(factory) {
+  externalFactory = factory;
+  exports.LoggerFactoryImpl.reset();
+  externalFactory = factory;
+}
+function createLogger(name) {
+  return exports.LoggerFactoryImpl.getLogger(name);
+}
+var __defProp2, __defNormalProp, __publicField, _ConsoleLogger; exports.ConsoleLogger = void 0; var externalFactory; exports.LoggerFactoryImpl = void 0;
+var init_dist = __esm({
+  "../common/dist/index.js"() {
+    __defProp2 = Object.defineProperty;
+    __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    _ConsoleLogger = class _ConsoleLogger2 {
+      constructor(name, options = {}) {
+        __publicField(this, "name");
+        __publicField(this, "level");
+        __publicField(this, "colors");
+        __publicField(this, "timestamps");
+        this.name = name;
+        this.level = options.level ?? "info";
+        this.colors = options.colors ?? this.isNodeEnvironment();
+        this.timestamps = options.timestamps ?? true;
+      }
+      debug(message, context) {
+        if (this.isDebugEnabled()) {
+          this.log("DEBUG", message, context);
+        }
+      }
+      info(message, context) {
+        if (this.isInfoEnabled()) {
+          this.log("INFO", message, context);
+        }
+      }
+      warn(message, context) {
+        if (this.isWarnEnabled()) {
+          this.log("WARN", message, context);
+        }
+      }
+      error(message, context) {
+        if (this.isErrorEnabled()) {
+          if (message instanceof Error) {
+            this.log("ERROR", message.message, { ...context, stack: message.stack });
+          } else {
+            this.log("ERROR", message, context);
+          }
+        }
+      }
+      isDebugEnabled() {
+        return this.getLevelValue(this.level) <= this.getLevelValue("debug");
+      }
+      isInfoEnabled() {
+        return this.getLevelValue(this.level) <= this.getLevelValue("info");
+      }
+      isWarnEnabled() {
+        return this.getLevelValue(this.level) <= this.getLevelValue("warn");
+      }
+      isErrorEnabled() {
+        return this.getLevelValue(this.level) <= this.getLevelValue("error");
+      }
+      getLevelValue(level) {
+        const levels = {
+          debug: 0,
+          info: 1,
+          warn: 2,
+          error: 3,
+          silent: 4
+        };
+        return levels[level];
+      }
+      log(level, message, context) {
+        const parts = [];
+        if (this.timestamps) {
+          parts.push((/* @__PURE__ */ new Date()).toISOString());
+        }
+        if (this.colors) {
+          const color = _ConsoleLogger2.COLORS[level];
+          parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger2.COLORS.RESET}`);
+        } else {
+          parts.push(level.padEnd(5));
+        }
+        parts.push(`[${this.name}]`);
+        parts.push(message);
+        const logLine = parts.join(" ");
+        const consoleMethod = this.getConsoleMethod(level);
+        if (context && Object.keys(context).length > 0) {
+          consoleMethod(logLine, context);
+        } else {
+          consoleMethod(logLine);
+        }
+      }
+      getConsoleMethod(level) {
+        switch (level) {
+          case "DEBUG":
+            return console.debug.bind(console);
+          case "INFO":
+            return console.info.bind(console);
+          case "WARN":
+            return console.warn.bind(console);
+          case "ERROR":
+            return console.error.bind(console);
+          default:
+            return console.log.bind(console);
+        }
+      }
+      isNodeEnvironment() {
+        return typeof process !== "undefined" && process.versions?.node !== void 0;
+      }
+    };
+    __publicField(_ConsoleLogger, "COLORS", {
+      DEBUG: "\x1B[36m",
+      INFO: "\x1B[32m",
+      WARN: "\x1B[33m",
+      ERROR: "\x1B[31m",
+      RESET: "\x1B[0m"
+    });
+    exports.ConsoleLogger = _ConsoleLogger;
+    externalFactory = null;
+    exports.LoggerFactoryImpl = class {
+      static getLogger(nameOrClass) {
+        const name = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
+        if (this.loggers.has(name)) {
+          return this.loggers.get(name);
+        }
+        const lazyLogger = this.createLazyLogger(name);
+        this.loggers.set(name, lazyLogger);
+        return lazyLogger;
+      }
+      static configure(config) {
+        this.config = { ...this.config, ...config };
+      }
+      static reset() {
+        this.loggers.clear();
+        this.config = { defaultLevel: "info" };
+        externalFactory = null;
+      }
+      static createLazyLogger(name) {
+        let realLogger = null;
+        const getRealLogger = () => {
+          if (!realLogger) {
+            realLogger = this.createLogger(name);
+          }
+          return realLogger;
+        };
+        return {
+          name,
+          level: this.config.defaultLevel || "info",
+          debug: (message, context) => getRealLogger().debug(message, context),
+          info: (message, context) => getRealLogger().info(message, context),
+          warn: (message, context) => getRealLogger().warn(message, context),
+          error: (message, context) => getRealLogger().error(message, context),
+          isDebugEnabled: () => getRealLogger().isDebugEnabled(),
+          isInfoEnabled: () => getRealLogger().isInfoEnabled(),
+          isWarnEnabled: () => getRealLogger().isWarnEnabled(),
+          isErrorEnabled: () => getRealLogger().isErrorEnabled()
+        };
+      }
+      static createLogger(name) {
+        if (externalFactory) {
+          return externalFactory.getLogger(name);
+        }
+        if (this.config.defaultImplementation) {
+          return this.config.defaultImplementation(name);
+        }
+        return new exports.ConsoleLogger(name, {
+          level: this.config.defaultLevel,
+          ...this.config.consoleOptions
+        });
+      }
+    };
+    __publicField(exports.LoggerFactoryImpl, "loggers", /* @__PURE__ */ new Map());
+    __publicField(exports.LoggerFactoryImpl, "config", {
+      defaultLevel: "info"
+    });
+  }
+});
+
 // src/createLocalAgentX.ts
 var createLocalAgentX_exports = {};
 __export(createLocalAgentX_exports, {
@@ -58,7 +240,7 @@ function setupBroadcasting(connections, runtime) {
 }
 async function createLocalAgentX(config) {
   if (config.logger) {
-    const { LoggerFactoryImpl: LoggerFactoryImpl2, setLoggerFactory: setLoggerFactory2 } = await import('@agentxjs/common');
+    const { LoggerFactoryImpl: LoggerFactoryImpl2, setLoggerFactory: setLoggerFactory2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
     LoggerFactoryImpl2.configure({
       defaultLevel: config.logger.level,
       consoleOptions: config.logger.console
@@ -162,12 +344,24 @@ async function createLocalAgentX(config) {
 var logger;
 var init_createLocalAgentX = __esm({
   "src/createLocalAgentX.ts"() {
-    logger = common.createLogger("agentx/createAgentX");
+    init_dist();
+    logger = createLogger("agentx/createAgentX");
   }
 });
-var remoteLogger = common.createLogger("agentx/RemoteClient");
+
+// ../types/dist/agentx.js
+function isRemoteConfig(config) {
+  return "serverUrl" in config && typeof config.serverUrl === "string";
+}
+function isLocalConfig(config) {
+  return !isRemoteConfig(config);
+}
+
+// src/createAgentX.ts
+init_dist();
+var remoteLogger = createLogger("agentx/RemoteClient");
 async function createAgentX(config) {
-  if (config && agentx.isRemoteConfig(config)) {
+  if (config && isRemoteConfig(config)) {
     return createRemoteAgentX(config.serverUrl);
   }
   const { createLocalAgentX: createLocalAgentX2 } = await Promise.resolve().then(() => (init_createLocalAgentX(), createLocalAgentX_exports));
@@ -306,83 +500,68 @@ async function createRemoteAgentX(serverUrl) {
   };
 }
 
-Object.defineProperty(exports, "ConsoleLogger", {
-  enumerable: true,
-  get: function () { return common.ConsoleLogger; }
-});
-Object.defineProperty(exports, "LoggerFactoryImpl", {
-  enumerable: true,
-  get: function () { return common.LoggerFactoryImpl; }
-});
-Object.defineProperty(exports, "createLogger", {
-  enumerable: true,
-  get: function () { return common.createLogger; }
-});
-Object.defineProperty(exports, "setLoggerFactory", {
-  enumerable: true,
-  get: function () { return common.setLoggerFactory; }
-});
-Object.defineProperty(exports, "isLocalConfig", {
-  enumerable: true,
-  get: function () { return agentx.isLocalConfig; }
-});
-Object.defineProperty(exports, "isRemoteConfig", {
-  enumerable: true,
-  get: function () { return agentx.isRemoteConfig; }
-});
-Object.defineProperty(exports, "hasIntent", {
-  enumerable: true,
-  get: function () { return event.hasIntent; }
-});
-Object.defineProperty(exports, "isAgentEvent", {
-  enumerable: true,
-  get: function () { return event.isAgentEvent; }
-});
-Object.defineProperty(exports, "isAgentMessageEvent", {
-  enumerable: true,
-  get: function () { return event.isAgentMessageEvent; }
-});
-Object.defineProperty(exports, "isAgentStateEvent", {
-  enumerable: true,
-  get: function () { return event.isAgentStateEvent; }
-});
-Object.defineProperty(exports, "isAgentStreamEvent", {
-  enumerable: true,
-  get: function () { return event.isAgentStreamEvent; }
-});
-Object.defineProperty(exports, "isAgentTurnEvent", {
-  enumerable: true,
-  get: function () { return event.isAgentTurnEvent; }
-});
-Object.defineProperty(exports, "isCommandEvent", {
-  enumerable: true,
-  get: function () { return event.isCommandEvent; }
-});
-Object.defineProperty(exports, "isCommandRequest", {
-  enumerable: true,
-  get: function () { return event.isCommandRequest; }
-});
-Object.defineProperty(exports, "isCommandResponse", {
-  enumerable: true,
-  get: function () { return event.isCommandResponse; }
-});
-Object.defineProperty(exports, "isFromSource", {
-  enumerable: true,
-  get: function () { return event.isFromSource; }
-});
-Object.defineProperty(exports, "isNotification", {
-  enumerable: true,
-  get: function () { return event.isNotification; }
-});
-Object.defineProperty(exports, "isRequest", {
-  enumerable: true,
-  get: function () { return event.isRequest; }
-});
-Object.defineProperty(exports, "isResult", {
-  enumerable: true,
-  get: function () { return event.isResult; }
-});
+// ../types/dist/event.js
+function isFromSource(event, source) {
+  return event.source === source;
+}
+function hasIntent(event, intent) {
+  return event.intent === intent;
+}
+function isRequest(event) {
+  return event.intent === "request";
+}
+function isResult(event) {
+  return event.intent === "result";
+}
+function isNotification(event) {
+  return event.intent === "notification";
+}
+function isCommandEvent(event) {
+  return event.source === "command";
+}
+function isCommandRequest(event) {
+  return event.source === "command" && event.category === "request";
+}
+function isCommandResponse(event) {
+  return event.source === "command" && event.category === "response";
+}
+function isAgentStreamEvent(event) {
+  return event.source === "agent" && event.category === "stream";
+}
+function isAgentStateEvent(event) {
+  return event.source === "agent" && event.category === "state";
+}
+function isAgentMessageEvent(event) {
+  return event.source === "agent" && event.category === "message";
+}
+function isAgentTurnEvent(event) {
+  return event.source === "agent" && event.category === "turn";
+}
+function isAgentEvent(event) {
+  return event.source === "agent";
+}
+
+// src/index.ts
+init_dist();
+
 exports.createAgentX = createAgentX;
+exports.createLogger = createLogger;
 exports.createRemoteAgentX = createRemoteAgentX;
+exports.hasIntent = hasIntent;
+exports.isAgentEvent = isAgentEvent;
+exports.isAgentMessageEvent = isAgentMessageEvent;
+exports.isAgentStateEvent = isAgentStateEvent;
+exports.isAgentStreamEvent = isAgentStreamEvent;
+exports.isAgentTurnEvent = isAgentTurnEvent;
+exports.isCommandEvent = isCommandEvent;
+exports.isCommandRequest = isCommandRequest;
+exports.isCommandResponse = isCommandResponse;
+exports.isFromSource = isFromSource;
+exports.isLocalConfig = isLocalConfig;
+exports.isNotification = isNotification;
+exports.isRemoteConfig = isRemoteConfig;
+exports.isRequest = isRequest;
+exports.isResult = isResult;
+exports.setLoggerFactory = setLoggerFactory;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map