conduithub 0.0.3 → 1.0.0

package/dist/shared/conduithub.BqUYv04j.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+class ConduithubError extends Error {
+  code;
+  details;
+  timestamp;
+  constructor(message, context) {
+    super(message);
+    this.name = "ConduithubError";
+    this.code = context?.code;
+    this.details = context?.details;
+    this.timestamp = context?.timestamp ?? Date.now();
+    Error.captureStackTrace?.(this, ConduithubError);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      timestamp: this.timestamp,
+      stack: this.stack
+    };
+  }
+}
+class PackageManagerRegistry {
+  manager = "";
+  set(manager) {
+    if (!this.isValidManager(manager)) {
+      throw new ConduithubError(`Invalid package manager: ${manager}`, {
+        code: "INVALID_PACKAGE_MANAGER",
+        details: { manager, validManagers: ["npm", "pnpm", "yarn", "bun"] }
+      });
+    }
+    this.manager = manager;
+  }
+  get() {
+    return this.manager;
+  }
+  isValidManager(manager) {
+    return ["npm", "pnpm", "yarn", "bun"].includes(manager);
+  }
+}
+const packageManagerRegistry = new PackageManagerRegistry();
+function setPkgManager(manager) {
+  packageManagerRegistry.set(manager);
+}
+function getPkgManager() {
+  return packageManagerRegistry.get();
+}
+class MissingDependencyError extends ConduithubError {
+  constructor(pkgName) {
+    const manager = getPkgManager() || "npm";
+    const message = `The package ${pkgName} is missing from the dependencies. Please install it using "${manager} add ${pkgName}"`;
+    super(message, {
+      code: "MISSING_DEPENDENCY",
+      details: {
+        packageName: pkgName,
+        suggestedCommand: `${manager} add ${pkgName}`
+      }
+    });
+  }
+}
+
+exports.ConduithubError = ConduithubError;
+exports.MissingDependencyError = MissingDependencyError;
+exports.getPkgManager = getPkgManager;
+exports.setPkgManager = setPkgManager;

package/dist/shared/conduithub.Bq_7Xj0J.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+const uuid = require('uuid');
+
+function generateUuid() {
+  return uuid.v4();
+}
+function generateShortId() {
+  return generateUuid().split("-")[0];
+}
+function isValidUuid(value) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(value);
+}
+
+exports.generateShortId = generateShortId;
+exports.generateUuid = generateUuid;
+exports.isValidUuid = isValidUuid;

package/dist/shared/conduithub.BzLwccre.d.mts

@@ -0,0 +1,52 @@
+import { a as Logger } from './conduithub.B7aryjPG.mjs';
+
+interface EventData<T extends string, P> {
+    type: T;
+    payload: P;
+    timestamp: number;
+    source: string;
+    context?: Record<string, unknown>;
+}
+
+interface EventBusOptions<EM extends Record<string, unknown>> {
+    readonly logger?: Logger;
+    readonly maxHandlersPerEvent?: number;
+    readonly handlerTimeoutMs?: number;
+    readonly onError?: (err: unknown, eventType: keyof EM) => void;
+}
+interface EventBusStats<EM extends Record<string, unknown>> {
+    readonly totalEvents: number;
+    readonly totalListeners: number;
+    readonly eventNames: (keyof EM)[];
+    readonly listenerCount: Record<keyof EM, number>;
+}
+declare class EventBus<EM extends Record<string, unknown>> {
+    private readonly handlers;
+    private readonly locks;
+    private initialized;
+    private readonly logger;
+    private readonly maxHandlersPerEvent;
+    private readonly handlerTimeoutMs;
+    private readonly onError?;
+    constructor(options?: EventBusOptions<EM>);
+    private withEventLock;
+    private ensureInitialized;
+    private sanitizeLog;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    private getTotalHandlerCount;
+    private clearAllHandlers;
+    on<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>, context?: Record<string, unknown>, signal?: AbortSignal) => Promise<void> | void, priority?: number, customId?: string): string;
+    once<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>, context?: Record<string, unknown>, signal?: AbortSignal) => Promise<void> | void, priority?: number, customId?: string): string;
+    private registerHandler;
+    off<K extends keyof EM>(type: K, id?: string): void;
+    emit<K extends keyof EM>(type: K, payload: EM[K], source?: string, context?: Record<string, unknown>): Promise<void>;
+    removeAllListeners<K extends keyof EM>(type?: K): void;
+    listenerCount<K extends keyof EM>(type: K): number;
+    eventNames(): Array<keyof EM>;
+    getStats(): EventBusStats<EM>;
+    get isInitialized(): boolean;
+}
+
+export { EventBus as E };
+export type { EventData as a };

package/dist/shared/conduithub.CkOQG3cD.mjs

@@ -0,0 +1,14 @@
+import { v4 } from 'uuid';
+
+function generateUuid() {
+  return v4();
+}
+function generateShortId() {
+  return generateUuid().split("-")[0];
+}
+function isValidUuid(value) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(value);
+}
+
+export { generateShortId as a, generateUuid as g, isValidUuid as i };

package/dist/shared/conduithub.CmZo_Vuc.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+const ERROR_CODE = {
+  // Configuration errors
+  INVALID_JSON: "Invalid JSON format",
+  INVALID_CONFIG: "Configuration validation failed",
+  UNSUPPORTED_CONFIG_FORMAT: "JavaScript config files are not supported. Use JSON format.",
+  // Initialization errors
+  STATE_MANAGER_NOT_INITIALIZED: "StateManager is not initialized",
+  SERVICE_CONTAINER_NOT_INITIALIZED: "Service Container is not initialized",
+  EVENT_BUS_NOT_INITIALIZED: "EventBus is not initialized",
+  HOOK_SYSTEM_NOT_INITIALIZED: "Hook system is not initialized",
+  // Handler limit errors
+  EVENT_HANDLER_LIMIT_EXCEEDED: "Handler limit exceeded for event",
+  HOOK_HANDLER_LIMIT_EXCEEDED: "Handler limit exceeded for hook",
+  // Duplicate ID errors
+  DUPLICATE_EVENT_HANDLER_ID: "Duplicate custom ID for event",
+  DUPLICATE_HOOK_HANDLER_ID: "Duplicate custom ID for hook",
+  // State management errors
+  INVALID_STATE_JSON_FORMAT: "Invalid state JSON format",
+  // Execution errors
+  HOOK_EXECUTION_FAILED: "Hook execution failed",
+  UNKNOWN_ERROR: "Unknown error",
+  // Service container errors
+  CIRCULAR_DEPENDENCY_DETECTED: "Circular dependency detected",
+  SERVICE_NOT_FOUND: "Service not found",
+  SERVICE_CREATION_FAILED: "Service creation failed",
+  SERVICE_IS_SINGLETON: "Service is a singleton and cannot be registered again",
+  // Plugin errors
+  PLUGIN_NOT_INITIALIZED: "Plugin is not initialized",
+  PLUGIN_ALREADY_INITIALIZED: "Plugin is already initialized",
+  PLUGIN_NOT_RUNNING: "Plugin is not running",
+  // ConfigManager errors
+  CONFIG_MANAGER_NOT_INITIALIZED: "ConfigManager is not initialized",
+  CONFIG_MANAGER_ALREADY_INITIALIZED: "ConfigManager is already initialized"
+};
+
+exports.ERROR_CODE = ERROR_CODE;

package/dist/shared/conduithub.DQO1dRnn.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+const ISO8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+function parseJson(data) {
+  try {
+    return JSON.parse(data, dateReviver);
+  } catch {
+    return null;
+  }
+}
+function stringifyJson(value, replacer, space) {
+  return JSON.stringify(value, replacer, space);
+}
+function safeStringifyJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[Circular or Non-Serializable Object]";
+  }
+}
+function dateReviver(_, value) {
+  if (typeof value === "string" && ISO8601_REGEX.test(value)) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return value;
+}
+
+exports.parseJson = parseJson;
+exports.safeStringifyJson = safeStringifyJson;
+exports.stringifyJson = stringifyJson;

package/dist/shared/conduithub.DQOWQ-Bx.d.ts

@@ -0,0 +1,52 @@
+import { a as Logger } from './conduithub.B7aryjPG.js';
+
+interface EventData<T extends string, P> {
+    type: T;
+    payload: P;
+    timestamp: number;
+    source: string;
+    context?: Record<string, unknown>;
+}
+
+interface EventBusOptions<EM extends Record<string, unknown>> {
+    readonly logger?: Logger;
+    readonly maxHandlersPerEvent?: number;
+    readonly handlerTimeoutMs?: number;
+    readonly onError?: (err: unknown, eventType: keyof EM) => void;
+}
+interface EventBusStats<EM extends Record<string, unknown>> {
+    readonly totalEvents: number;
+    readonly totalListeners: number;
+    readonly eventNames: (keyof EM)[];
+    readonly listenerCount: Record<keyof EM, number>;
+}
+declare class EventBus<EM extends Record<string, unknown>> {
+    private readonly handlers;
+    private readonly locks;
+    private initialized;
+    private readonly logger;
+    private readonly maxHandlersPerEvent;
+    private readonly handlerTimeoutMs;
+    private readonly onError?;
+    constructor(options?: EventBusOptions<EM>);
+    private withEventLock;
+    private ensureInitialized;
+    private sanitizeLog;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    private getTotalHandlerCount;
+    private clearAllHandlers;
+    on<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>, context?: Record<string, unknown>, signal?: AbortSignal) => Promise<void> | void, priority?: number, customId?: string): string;
+    once<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>, context?: Record<string, unknown>, signal?: AbortSignal) => Promise<void> | void, priority?: number, customId?: string): string;
+    private registerHandler;
+    off<K extends keyof EM>(type: K, id?: string): void;
+    emit<K extends keyof EM>(type: K, payload: EM[K], source?: string, context?: Record<string, unknown>): Promise<void>;
+    removeAllListeners<K extends keyof EM>(type?: K): void;
+    listenerCount<K extends keyof EM>(type: K): number;
+    eventNames(): Array<keyof EM>;
+    getStats(): EventBusStats<EM>;
+    get isInitialized(): boolean;
+}
+
+export { EventBus as E };
+export type { EventData as a };

package/dist/shared/conduithub.DsOOeNwU.cjs

@@ -0,0 +1,269 @@
+'use strict';
+
+class PluginManager {
+  constructor(eventBus, logger, serviceContainer, stateManager, hookSystem, configManager) {
+    this.eventBus = eventBus;
+    this.logger = logger;
+    this.serviceContainer = serviceContainer;
+    this.stateManager = stateManager;
+    this.hookSystem = hookSystem;
+    this.configManager = configManager;
+  }
+  plugins = /* @__PURE__ */ new Map();
+  pluginStatuses = /* @__PURE__ */ new Map();
+  pluginConfigs = /* @__PURE__ */ new Map();
+  log(level, message, ...args) {
+    const l = this.logger;
+    if (l && typeof l.log === "function") {
+      l.log(level, message, ...args);
+      return;
+    }
+    const anyLogger = l;
+    const fn = anyLogger?.[level];
+    if (typeof fn === "function") fn(message, ...args);
+  }
+  async registerPlugin(plugin, config) {
+    const pluginName = plugin.constructor.name;
+    if (this.plugins.has(pluginName)) {
+      throw new Error(`Plugin ${pluginName} already registered`);
+    }
+    try {
+      const existing = this.pluginConfigs.get(pluginName) ?? await this.configManager.getPluginConfig(pluginName);
+      const metaVersion = plugin.getMetadata().version;
+      const pluginConfig = {
+        name: pluginName,
+        version: config?.version ?? existing?.version ?? metaVersion,
+        enabled: config?.enabled ?? existing?.enabled ?? true,
+        dependencies: config?.dependencies ?? existing?.dependencies ?? [],
+        config: { ...existing?.config ?? {}, ...config?.config ?? {} }
+      };
+      plugin.updateConfig(pluginConfig);
+      this.plugins.set(pluginName, plugin);
+      this.pluginConfigs.set(pluginName, pluginConfig);
+      this.pluginStatuses.set(pluginName, {
+        name: pluginName,
+        version: pluginConfig.version,
+        status: "registered",
+        config: pluginConfig,
+        lastActivity: Date.now()
+      });
+      this.log("info", `Plugin ${pluginName} registered successfully`);
+      await this.hookSystem.executeHook("plugin:registered", {
+        plugin: pluginName,
+        config: pluginConfig
+      });
+      await this.eventBus.emit("plugin:registered", {
+        plugin: pluginName,
+        config: pluginConfig
+      });
+    } catch (error) {
+      this.log("error", `Failed to register plugin ${pluginName}`, error);
+      throw error;
+    }
+  }
+  async unregisterPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    try {
+      if (plugin.isPluginRunning()) {
+        await this.stopPlugin(pluginName);
+      }
+      if (plugin.isPluginInitialized()) {
+        await plugin.destroy();
+      }
+      this.plugins.delete(pluginName);
+      this.pluginConfigs.delete(pluginName);
+      this.pluginStatuses.delete(pluginName);
+      this.log("info", `Plugin ${pluginName} unregistered successfully`);
+      await this.eventBus.emit("plugin:unregistered", {
+        plugin: pluginName
+      });
+      await this.hookSystem.executeHook("plugin:unregistered", {
+        plugin: pluginName
+      });
+    } catch (error) {
+      this.log("error", `Failed to unregister plugin ${pluginName}`, error);
+      throw error;
+    }
+  }
+  async initializePlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    const status = this.pluginStatuses.get(pluginName);
+    if (status?.status === "initialized" || status?.status === "running") {
+      return;
+    }
+    try {
+      const context = {
+        eventBus: this.eventBus,
+        logger: this.logger,
+        config: this.pluginConfigs.get(pluginName),
+        serviceContainer: this.serviceContainer,
+        stateManager: this.stateManager,
+        hookSystem: this.hookSystem
+      };
+      await plugin.initialize(context);
+      this.pluginStatuses.set(pluginName, {
+        ...status,
+        status: "initialized",
+        lastActivity: Date.now()
+      });
+      this.log("info", `Plugin ${pluginName} initialized successfully`);
+      await this.eventBus.emit("plugin:initialized", { plugin: pluginName });
+      await this.hookSystem.executeHook("plugin:initialized", {
+        plugin: pluginName
+      });
+    } catch (error) {
+      this.log("error", `Failed to initialize plugin ${pluginName}`, error);
+      throw error;
+    }
+  }
+  async startPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    const status = this.pluginStatuses.get(pluginName);
+    if (status?.status === "running") {
+      return;
+    }
+    try {
+      if (!plugin.isPluginInitialized()) {
+        await this.initializePlugin(pluginName);
+      }
+      await plugin.start();
+      this.pluginStatuses.set(pluginName, {
+        ...status,
+        status: "running",
+        lastActivity: Date.now()
+      });
+      this.log("info", `Plugin ${pluginName} started successfully`);
+      await this.eventBus.emit("plugin:started", { plugin: pluginName });
+      await this.hookSystem.executeHook("plugin:started", {
+        plugin: pluginName
+      });
+    } catch (error) {
+      this.pluginStatuses.set(pluginName, {
+        ...this.pluginStatuses.get(pluginName),
+        status: "error",
+        error: error instanceof Error ? error.message : String(error),
+        lastActivity: Date.now()
+      });
+      this.log("error", `Failed to start plugin ${pluginName}`, error);
+      throw error;
+    }
+  }
+  async stopPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    const status = this.pluginStatuses.get(pluginName);
+    if (status?.status !== "running") {
+      return;
+    }
+    try {
+      await plugin.stop();
+      this.pluginStatuses.set(pluginName, {
+        ...status,
+        status: "stopped",
+        lastActivity: Date.now()
+      });
+      this.log("info", `Plugin ${pluginName} stopped successfully`);
+      await this.eventBus.emit("plugin:stopped", { plugin: pluginName });
+      await this.hookSystem.executeHook("plugin:stopped", {
+        plugin: pluginName
+      });
+    } catch (error) {
+      this.pluginStatuses.set(pluginName, {
+        ...this.pluginStatuses.get(pluginName),
+        status: "error",
+        error: error instanceof Error ? error.message : String(error),
+        lastActivity: Date.now()
+      });
+    }
+  }
+  async shutdownAll() {
+    this.log("info", "Shutting down all plugins...");
+    const shutdownPromises = Array.from(this.plugins.keys()).map(
+      async (pluginName) => {
+        try {
+          await this.unregisterPlugin(pluginName);
+        } catch (error) {
+          this.log("error", `Failed to shutdown plugin ${pluginName}`, error);
+        }
+      }
+    );
+    await Promise.all(shutdownPromises);
+    this.log("info", "All plugins shutdown successfully");
+  }
+  isPluginRegistered(pluginName) {
+    return this.plugins.has(pluginName);
+  }
+  isPluginRunning(pluginName) {
+    const status = this.pluginStatuses.get(pluginName);
+    return status?.status === "running";
+  }
+  getPluginStatus(pluginName) {
+    return this.pluginStatuses.get(pluginName);
+  }
+  listPlugins() {
+    return Array.from(this.plugins.keys());
+  }
+  getAllPluginStatuses() {
+    return Array.from(this.pluginStatuses.values());
+  }
+  getPlugin(pluginName) {
+    return this.plugins.get(pluginName);
+  }
+  getPluginConfig(pluginName) {
+    return this.pluginConfigs.get(pluginName);
+  }
+  async updatePluginConfig(pluginName, config) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    try {
+      const currentConfig = this.pluginConfigs.get(pluginName);
+      if (!currentConfig) {
+        throw new Error(`Plugin config not found for ${pluginName}`);
+      }
+      const newConfig = {
+        name: currentConfig.name,
+        version: config?.version ?? currentConfig.version,
+        enabled: config?.enabled ?? currentConfig.enabled,
+        dependencies: config?.dependencies ?? currentConfig.dependencies ?? [],
+        config: { ...currentConfig.config ?? {}, ...config?.config ?? {} }
+      };
+      this.pluginConfigs.set(pluginName, newConfig);
+      plugin.updateConfig(newConfig);
+      const status = this.pluginStatuses.get(pluginName);
+      if (status) {
+        this.pluginStatuses.set(pluginName, {
+          ...status,
+          config: newConfig,
+          lastActivity: Date.now()
+        });
+      }
+      this.log("info", `Plugin ${pluginName} config updated successfully`);
+      await this.eventBus.emit("plugin:configUpdated", {
+        plugin: pluginName,
+        config: newConfig
+      });
+      await this.hookSystem.executeHook("plugin:configUpdated", {
+        plugin: pluginName,
+        config: newConfig
+      });
+    } catch (error) {
+      this.log("error", `Failed to update plugin ${pluginName} config`, error);
+      throw error;
+    }
+  }
+}
+
+exports.PluginManager = PluginManager;