@bernierllc/chat-suite 1.0.0

package/dist/utils/user-mapping.js

@@ -0,0 +1,110 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserMapper = void 0;
+exports.createUnifiedId = createUnifiedId;
+/**
+ * User mapping storage
+ */
+class UserMapper {
+    constructor() {
+        this.identities = new Map();
+        this.providerIndex = new Map(); // provider:userId -> unifiedId
+    }
+    /**
+     * Create or update a user identity
+     */
+    mapUser(identity) {
+        this.identities.set(identity.unifiedId, identity);
+        // Update provider index
+        identity.platformIds.forEach((platformUserId, provider) => {
+            const key = this.getProviderKey(provider, platformUserId);
+            this.providerIndex.set(key, identity.unifiedId);
+        });
+    }
+    /**
+     * Get unified user ID from platform-specific ID
+     */
+    getUnifiedId(provider, platformUserId) {
+        const key = this.getProviderKey(provider, platformUserId);
+        return this.providerIndex.get(key);
+    }
+    /**
+     * Get platform-specific user ID from unified ID
+     */
+    getPlatformId(unifiedId, provider) {
+        const identity = this.identities.get(unifiedId);
+        return identity?.platformIds.get(provider);
+    }
+    /**
+     * Get full user identity
+     */
+    getIdentity(unifiedId) {
+        return this.identities.get(unifiedId);
+    }
+    /**
+     * Add platform ID to existing user
+     */
+    addPlatformId(unifiedId, provider, platformUserId) {
+        const identity = this.identities.get(unifiedId);
+        if (!identity) {
+            return false;
+        }
+        identity.platformIds.set(provider, platformUserId);
+        this.mapUser(identity);
+        return true;
+    }
+    /**
+     * Remove user identity
+     */
+    removeUser(unifiedId) {
+        const identity = this.identities.get(unifiedId);
+        if (!identity) {
+            return false;
+        }
+        // Remove from provider index
+        identity.platformIds.forEach((platformUserId, provider) => {
+            const key = this.getProviderKey(provider, platformUserId);
+            this.providerIndex.delete(key);
+        });
+        return this.identities.delete(unifiedId);
+    }
+    /**
+     * Get all users
+     */
+    getAllUsers() {
+        return Array.from(this.identities.values());
+    }
+    /**
+     * Clear all mappings
+     */
+    clear() {
+        this.identities.clear();
+        this.providerIndex.clear();
+    }
+    /**
+     * Get number of mapped users
+     */
+    size() {
+        return this.identities.size;
+    }
+    /**
+     * Create provider key for indexing
+     */
+    getProviderKey(provider, platformUserId) {
+        return `${provider}:${platformUserId}`;
+    }
+}
+exports.UserMapper = UserMapper;
+/**
+ * Create a new unified user ID
+ */
+function createUnifiedId() {
+    return `user_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}

package/jest.config.cjs

@@ -0,0 +1,30 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+module.exports = {
+  preset: 'ts-jest',
+  // Use fixed environment to handle Node.js v25+ localStorage issue
+  testEnvironment: '<rootDir>/../../../jest-environment-node-fixed.cjs',
+  roots: ['<rootDir>/__tests__'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.{ts,tsx}',
+    '!src/**/*.d.ts',
+    '!src/index.ts'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  },
+  coverageDirectory: 'coverage',
+  verbose: true
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@bernierllc/chat-suite",
+  "version": "1.0.0",
+  "description": "Comprehensive chat orchestration suite with AI-powered routing",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "chat",
+    "suite",
+    "orchestration",
+    "ai-routing",
+    "chatkit",
+    "slack",
+    "discord",
+    "teams",
+    "multi-provider"
+  ],
+  "author": "Bernier LLC",
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "zod": "^3.22.0",
+    "@bernierllc/neverhub-adapter": "0.1.2",
+    "@bernierllc/chatkit-adapter": "1.0.0",
+    "@bernierllc/chat-ai-router": "1.0.0",
+    "@bernierllc/chat-analytics": "1.0.0"
+  },
+  "peerDependencies": {},
+  "peerDependenciesMeta": {
+    "@bernierllc/chat-integration-slack": {
+      "optional": true
+    },
+    "@bernierllc/chat-integration-discord": {
+      "optional": true
+    },
+    "@bernierllc/chat-integration-teams": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  },
+  "bernierllc": {
+    "category": "suite",
+    "integration": {
+      "neverhub": "required"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --watch",
+    "test:run": "jest --passWithNoTests",
+    "test:coverage": "jest --coverage --passWithNoTests",
+    "lint": "eslint src/**/*.ts",
+    "clean": "rm -rf dist"
+  }
+}

package/src/ChatSuite.ts

@@ -0,0 +1,347 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { NeverHubAdapter } from '@bernierllc/neverhub-adapter';
+import type {
+  ChatSuiteConfig,
+  SuiteInitResult,
+  ChatSuiteHealth,
+  BroadcastConfig,
+  ProviderMessage,
+  ProviderMessageResult,
+  SuiteResult,
+  Provider,
+  ProviderType
+} from './types';
+import { ConfigManager } from './services/ConfigManager';
+import { UserManager } from './services/UserManager';
+import { HealthMonitor } from './services/HealthMonitor';
+import { ProviderManager } from './services/ProviderManager';
+import { MessageOrchestrator } from './services/MessageOrchestrator';
+import { ChatKitProvider } from './providers/ChatKitProvider';
+import { MessageBridge } from './utils/message-bridge';
+import { ChatSuiteError, ChatSuiteErrorType } from './utils/error-handling';
+import {
+  registerWithNeverHub,
+  unregisterFromNeverHub,
+  updateHealthStatus,
+  discoverAllChatServices,
+  publishMessageEvent,
+  publishProviderEvent,
+  ChatSuiteEventType
+} from './neverhub';
+
+/**
+ * Main chat suite orchestration class
+ */
+export class ChatSuite {
+  private configManager: ConfigManager;
+  private userManager: UserManager;
+  private healthMonitor: HealthMonitor;
+  private providerManager: ProviderManager;
+  private messageOrchestrator: MessageOrchestrator;
+
+  private neverhubAdapter?: NeverHubAdapter;
+  private neverhubConnected = false;
+  private initialized = false;
+
+  constructor(config?: Partial<ChatSuiteConfig>) {
+    this.configManager = new ConfigManager(config);
+    this.userManager = new UserManager();
+    this.healthMonitor = new HealthMonitor();
+    this.providerManager = new ProviderManager();
+    this.messageOrchestrator = new MessageOrchestrator();
+  }
+
+  /**
+   * Initialize the chat suite
+   */
+  public async initialize(): Promise<SuiteInitResult> {
+    try {
+      const config = this.configManager.getConfig();
+
+      // 1. Initialize NeverHub (if enabled)
+      if (config.neverhub?.enabled) {
+        await this.initializeNeverHub();
+      }
+
+      // 2. Initialize ChatKit provider (always required)
+      const chatKitResult = await this.initializeChatKitProvider(config);
+      if (!chatKitResult.success) {
+        throw new ChatSuiteError(
+          ChatSuiteErrorType.INITIALIZATION_ERROR,
+          `Failed to initialize ChatKit: ${chatKitResult.error}`
+        );
+      }
+
+      // 3. Initialize message bridge (if configured)
+      if (config.messageBridge) {
+        const bridge = new MessageBridge(config.messageBridge);
+        this.messageOrchestrator.setMessageBridge(bridge);
+      }
+
+      // 4. Start health monitoring
+      this.healthMonitor.startMonitoring(60000);
+
+      // 5. Update NeverHub health status
+      if (this.neverhubConnected && this.neverhubAdapter) {
+        await updateHealthStatus(this.neverhubAdapter, 'healthy', {
+          providersInitialized: this.providerManager.getProviderCount().initialized
+        });
+      }
+
+      this.initialized = true;
+
+      return {
+        success: true,
+        providersInitialized: this.getInitializedProviderTypes(),
+        providersFailed: [],
+        aiRoutingEnabled: config.aiRouting?.enabled || false,
+        analyticsEnabled: config.analytics?.enabled || false,
+        neverhubConnected: this.neverhubConnected
+      };
+    } catch (error) {
+      return {
+        success: false,
+        providersInitialized: [],
+        providersFailed: ['chatkit'],
+        aiRoutingEnabled: false,
+        analyticsEnabled: false,
+        neverhubConnected: false,
+        error: error instanceof Error ? error.message : 'Initialization failed'
+      };
+    }
+  }
+
+  /**
+   * Initialize NeverHub connection
+   */
+  private async initializeNeverHub(): Promise<void> {
+    try {
+      const detected = await NeverHubAdapter.detect();
+      if (!detected) {
+        console.log('⚠️  NeverHub not available - running without service discovery');
+        return;
+      }
+
+      this.neverhubAdapter = new NeverHubAdapter();
+      const config = this.configManager.getConfig();
+
+      if (config.neverhub) {
+        const registered = await registerWithNeverHub(this.neverhubAdapter, config.neverhub);
+        if (registered) {
+          this.neverhubConnected = true;
+
+          // Discover available services
+          const discovered = await discoverAllChatServices(this.neverhubAdapter);
+          console.log(`✅ Discovered services:`, {
+            providers: discovered.providers.length,
+            aiRouter: !!discovered.aiRouter,
+            analytics: !!discovered.analytics
+          });
+        }
+      }
+    } catch (error) {
+      console.error('❌ NeverHub initialization failed (continuing without):', error);
+      this.neverhubConnected = false;
+    }
+  }
+
+  /**
+   * Initialize ChatKit provider
+   */
+  private async initializeChatKitProvider(config: ChatSuiteConfig): Promise<SuiteResult<void>> {
+    try {
+      const chatKitConfig = config.providers.chatkit;
+      if (!chatKitConfig || !chatKitConfig.enabled) {
+        return {
+          success: false,
+          error: 'ChatKit provider is not enabled in configuration'
+        };
+      }
+
+      const provider = new ChatKitProvider({
+        serviceName: chatKitConfig.config.serviceName as string,
+        features: chatKitConfig.config.features as string[],
+        config: chatKitConfig.config
+      });
+
+      // Register provider
+      const registerResult = this.providerManager.registerProvider({
+        provider,
+        priority: chatKitConfig.priority,
+        enabled: chatKitConfig.enabled
+      });
+
+      if (!registerResult.success) {
+        return registerResult;
+      }
+
+      // Initialize provider
+      const initResult = await this.providerManager.initializeProvider('chatkit');
+      if (!initResult.success) {
+        return initResult;
+      }
+
+      // Register with health monitor
+      this.healthMonitor.registerProvider(provider);
+
+      // Publish provider initialized event
+      if (this.neverhubConnected && this.neverhubAdapter) {
+        await publishProviderEvent(
+          this.neverhubAdapter,
+          ChatSuiteEventType.PROVIDER_INITIALIZED,
+          'chatkit'
+        );
+      }
+
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to initialize ChatKit'
+      };
+    }
+  }
+
+  /**
+   * Send a message through a specific provider
+   */
+  public async sendMessage(
+    providerType: ProviderType,
+    message: ProviderMessage
+  ): Promise<SuiteResult<ProviderMessageResult>> {
+    if (!this.initialized) {
+      return {
+        success: false,
+        error: 'Chat suite is not initialized'
+      };
+    }
+
+    const provider = this.providerManager.getProvider(providerType);
+    if (!provider) {
+      return {
+        success: false,
+        error: `Provider ${providerType} not found`
+      };
+    }
+
+    const result = await this.messageOrchestrator.sendMessage(provider, message);
+
+    // Publish message event
+    if (this.neverhubConnected && this.neverhubAdapter && result.success && result.data) {
+      await publishMessageEvent(this.neverhubAdapter, {
+        type: 'message.sent',
+        messageId: result.data.messageId || 'unknown',
+        provider: providerType,
+        timestamp: new Date(),
+        data: { content: message.content }
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Broadcast a message to multiple providers
+   */
+  public async broadcastMessage(
+    config: BroadcastConfig
+  ): Promise<SuiteResult<ProviderMessageResult[]>> {
+    if (!this.initialized) {
+      return {
+        success: false,
+        error: 'Chat suite is not initialized'
+      };
+    }
+
+    const providers = new Map<ProviderType, Provider>();
+
+    for (const type of config.platforms) {
+      const provider = this.providerManager.getProvider(type);
+      if (provider && this.providerManager.isInitialized(type)) {
+        providers.set(type, provider);
+      }
+    }
+
+    return this.messageOrchestrator.broadcastMessage(providers, config);
+  }
+
+  /**
+   * Get health status
+   */
+  public async getHealth(): Promise<ChatSuiteHealth> {
+    return this.healthMonitor.checkHealth();
+  }
+
+  /**
+   * Get user manager
+   */
+  public getUserManager(): UserManager {
+    return this.userManager;
+  }
+
+  /**
+   * Get config manager
+   */
+  public getConfigManager(): ConfigManager {
+    return this.configManager;
+  }
+
+  /**
+   * Check if initialized
+   */
+  public isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  /**
+   * Check if NeverHub is connected
+   */
+  public isNeverHubConnected(): boolean {
+    return this.neverhubConnected;
+  }
+
+  /**
+   * Get provider manager
+   */
+  public getProviderManager(): ProviderManager {
+    return this.providerManager;
+  }
+
+  /**
+   * Get message orchestrator
+   */
+  public getMessageOrchestrator(): MessageOrchestrator {
+    return this.messageOrchestrator;
+  }
+
+  /**
+   * Shutdown the chat suite
+   */
+  public async shutdown(): Promise<void> {
+    this.healthMonitor.stopMonitoring();
+    await this.providerManager.shutdownAll();
+
+    if (this.neverhubConnected && this.neverhubAdapter) {
+      await unregisterFromNeverHub(this.neverhubAdapter);
+    }
+
+    this.initialized = false;
+    this.neverhubConnected = false;
+  }
+
+  /**
+   * Get initialized provider types
+   */
+  private getInitializedProviderTypes(): ProviderType[] {
+    return this.providerManager
+      .getInitializedProviders()
+      .map(p => p.type);
+  }
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+// Main export
+export { ChatSuite } from './ChatSuite';
+
+// Types
+export * from './types';
+
+// Services
+export * from './services';
+
+// Providers
+export * from './providers';
+
+// Utilities
+export * from './utils';
+
+// NeverHub integration
+export * from './neverhub';