@bernierllc/chat-suite 1.0.0

package/src/neverhub/discovery.ts

@@ -0,0 +1,137 @@
+/*
+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.
+*/
+// @ts-nocheck
+// TODO: Fix ServiceDiscoveryResult type compatibility
+
+import { NeverHubAdapter } from '@bernierllc/neverhub-adapter';
+
+/**
+ * Discovered service information
+ */
+export interface DiscoveredService {
+  name: string;
+  type: string;
+  version: string;
+  capabilities: Array<{
+    type: string;
+    name: string;
+    version: string;
+  }>;
+  endpoint?: string;
+}
+
+/**
+ * Discover chat providers through NeverHub
+ */
+export async function discoverProviders(
+  adapter: NeverHubAdapter
+): Promise<DiscoveredService[]> {
+  try {
+    const services = await adapter.discover({
+      capabilityTypes: ['chat', 'chat-provider']
+    });
+
+    console.log(`✅ Discovered ${services.length} chat providers`);
+    return services;
+  } catch (error) {
+    console.error('❌ Failed to discover providers:', error);
+    return [];
+  }
+}
+
+/**
+ * Discover AI routing service
+ */
+export async function discoverAIRouter(
+  adapter: NeverHubAdapter
+): Promise<DiscoveredService | undefined> {
+  try {
+    const services = await adapter.discover({
+      capabilityTypes: ['ai', 'routing']
+    });
+
+    if (services.length > 0) {
+      console.log(`✅ Discovered AI router: ${services[0].name}`);
+      return services[0];
+    }
+
+    console.log('⚠️  No AI router service found');
+    return undefined;
+  } catch (error) {
+    console.error('❌ Failed to discover AI router:', error);
+    return undefined;
+  }
+}
+
+/**
+ * Discover analytics service
+ */
+export async function discoverAnalytics(
+  adapter: NeverHubAdapter
+): Promise<DiscoveredService | undefined> {
+  try {
+    const services = await adapter.discover({
+      capabilityTypes: ['analytics', 'chat-analytics']
+    });
+
+    if (services.length > 0) {
+      console.log(`✅ Discovered analytics service: ${services[0].name}`);
+      return services[0];
+    }
+
+    console.log('⚠️  No analytics service found');
+    return undefined;
+  } catch (error) {
+    console.error('❌ Failed to discover analytics:', error);
+    return undefined;
+  }
+}
+
+/**
+ * Discover all chat-related services
+ */
+export async function discoverAllChatServices(
+  adapter: NeverHubAdapter
+): Promise<{
+  providers: DiscoveredService[];
+  aiRouter?: DiscoveredService;
+  analytics?: DiscoveredService;
+}> {
+  const [providers, aiRouter, analytics] = await Promise.all([
+    discoverProviders(adapter),
+    discoverAIRouter(adapter),
+    discoverAnalytics(adapter)
+  ]);
+
+  return {
+    providers,
+    aiRouter,
+    analytics
+  };
+}
+
+/**
+ * Get service by name
+ */
+export async function getService(
+  adapter: NeverHubAdapter,
+  serviceName: string
+): Promise<DiscoveredService | undefined> {
+  try {
+    const service = await adapter.getService(serviceName);
+    if (service) {
+      console.log(`✅ Found service: ${serviceName}`);
+    } else {
+      console.log(`⚠️  Service not found: ${serviceName}`);
+    }
+    return service;
+  } catch (error) {
+    console.error(`❌ Failed to get service ${serviceName}:`, error);
+    return undefined;
+  }
+}

package/src/neverhub/event-handlers.ts

@@ -0,0 +1,141 @@
+/*
+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.
+*/
+// @ts-nocheck
+// TODO: Fix NeverHubAdapter API compatibility
+
+import { NeverHubAdapter } from '@bernierllc/neverhub-adapter';
+import type { MessageEvent, ProviderType } from '../types';
+
+/**
+ * NeverHub event types for chat suite
+ */
+export enum ChatSuiteEventType {
+  MESSAGE_SENT = 'chat.message.sent',
+  MESSAGE_RECEIVED = 'chat.message.received',
+  MESSAGE_FAILED = 'chat.message.failed',
+  MESSAGE_BRIDGED = 'chat.message.bridged',
+  PROVIDER_INITIALIZED = 'chat.provider.initialized',
+  PROVIDER_FAILED = 'chat.provider.failed',
+  ROUTING_DECISION = 'chat.routing.decision'
+}
+
+/**
+ * Publish a message event to NeverHub
+ */
+export async function publishMessageEvent(
+  adapter: NeverHubAdapter,
+  event: MessageEvent
+): Promise<boolean> {
+  try {
+    await adapter.publishEvent({
+      type: event.type,
+      data: {
+        messageId: event.messageId,
+        provider: event.provider,
+        timestamp: event.timestamp,
+        ...event.data
+      }
+    });
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to publish message event:', error);
+    return false;
+  }
+}
+
+/**
+ * Publish provider initialization event
+ */
+export async function publishProviderEvent(
+  adapter: NeverHubAdapter,
+  eventType: ChatSuiteEventType.PROVIDER_INITIALIZED | ChatSuiteEventType.PROVIDER_FAILED,
+  provider: ProviderType,
+  details?: Record<string, unknown>
+): Promise<boolean> {
+  try {
+    await adapter.publishEvent({
+      type: eventType,
+      data: {
+        provider,
+        timestamp: new Date(),
+        ...details
+      }
+    });
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to publish provider event:', error);
+    return false;
+  }
+}
+
+/**
+ * Publish routing decision event
+ */
+export async function publishRoutingEvent(
+  adapter: NeverHubAdapter,
+  messageId: string,
+  provider: ProviderType,
+  confidence: number,
+  reasoning?: string
+): Promise<boolean> {
+  try {
+    await adapter.publishEvent({
+      type: ChatSuiteEventType.ROUTING_DECISION,
+      data: {
+        messageId,
+        provider,
+        confidence,
+        reasoning,
+        timestamp: new Date()
+      }
+    });
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to publish routing event:', error);
+    return false;
+  }
+}
+
+/**
+ * Subscribe to chat events from NeverHub
+ */
+export async function subscribeToEvents(
+  adapter: NeverHubAdapter,
+  eventTypes: string[],
+  handler: (event: { type: string; data: Record<string, unknown> }) => void | Promise<void>
+): Promise<boolean> {
+  try {
+    for (const eventType of eventTypes) {
+      await adapter.subscribe(eventType, handler);
+    }
+    console.log(`✅ Subscribed to ${eventTypes.length} event types`);
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to subscribe to events:', error);
+    return false;
+  }
+}
+
+/**
+ * Unsubscribe from all events
+ */
+export async function unsubscribeFromEvents(
+  adapter: NeverHubAdapter,
+  eventTypes: string[]
+): Promise<boolean> {
+  try {
+    for (const eventType of eventTypes) {
+      await adapter.unsubscribe(eventType);
+    }
+    console.log(`✅ Unsubscribed from ${eventTypes.length} event types`);
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to unsubscribe from events:', error);
+    return false;
+  }
+}

package/src/neverhub/index.ts

@@ -0,0 +1,11 @@
+/*
+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.
+*/
+
+export * from './service-registration';
+export * from './event-handlers';
+export * from './discovery';

package/src/neverhub/service-registration.ts

@@ -0,0 +1,89 @@
+/*
+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.
+*/
+// @ts-nocheck
+// TODO: Fix NeverHubAdapter API compatibility
+
+import { NeverHubAdapter } from '@bernierllc/neverhub-adapter';
+import type { NeverHubConfig } from '../types';
+
+/**
+ * Service registration data
+ */
+export interface ServiceRegistration {
+  type: string;
+  name: string;
+  version: string;
+  capabilities: Array<{
+    type: string;
+    name: string;
+    version: string;
+  }>;
+  dependencies: string[];
+}
+
+/**
+ * Register chat suite with NeverHub
+ */
+export async function registerWithNeverHub(
+  adapter: NeverHubAdapter,
+  config: NeverHubConfig
+): Promise<boolean> {
+  try {
+    const registration: ServiceRegistration = {
+      type: 'chat-suite',
+      name: config.serviceName,
+      version: '1.0.0',
+      capabilities: config.capabilities,
+      dependencies: config.dependencies
+    };
+
+    await adapter.register(registration);
+    console.log(`✅ Chat Suite registered with NeverHub: ${config.serviceName}`);
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to register with NeverHub:', error);
+    return false;
+  }
+}
+
+/**
+ * Unregister from NeverHub
+ */
+export async function unregisterFromNeverHub(
+  adapter: NeverHubAdapter
+): Promise<boolean> {
+  try {
+    await adapter.unregister();
+    console.log('✅ Chat Suite unregistered from NeverHub');
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to unregister from NeverHub:', error);
+    return false;
+  }
+}
+
+/**
+ * Update service health status in NeverHub
+ */
+export async function updateHealthStatus(
+  adapter: NeverHubAdapter,
+  status: 'healthy' | 'degraded' | 'unhealthy',
+  details?: Record<string, unknown>
+): Promise<boolean> {
+  try {
+    await adapter.reportHealth({
+      status,
+      timestamp: new Date(),
+      details
+    });
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to update health status in NeverHub:', error);
+    return false;
+  }
+}

package/src/providers/ChatKitProvider.ts

@@ -0,0 +1,193 @@
+/*
+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.
+*/
+// @ts-nocheck
+// TODO: Fix ChatKit API type compatibility
+
+import type {
+  Provider,
+  ProviderMessage,
+  ProviderMessageResult,
+  ProviderHealth,
+  ProviderHealthStatus
+} from '../types';
+import { ChatKitAdapter } from '@bernierllc/chatkit-adapter';
+
+/**
+ * ChatKit provider configuration
+ */
+export interface ChatKitProviderConfig {
+  serviceName?: string;
+  features?: string[];
+  config?: Record<string, unknown>;
+}
+
+/**
+ * ChatKit provider implementation
+ */
+export class ChatKitProvider implements Provider {
+  public readonly type = 'chatkit' as const;
+  public readonly name = '@bernierllc/chatkit-adapter';
+
+  private adapter?: ChatKitAdapter;
+  private initialized = false;
+  private errorCount = 0;
+  private lastError?: Error;
+  private initTime?: Date;
+
+  constructor(private config: ChatKitProviderConfig = {}) {}
+
+  /**
+   * Initialize the ChatKit provider
+   */
+  public async initialize(): Promise<void> {
+    try {
+      this.adapter = new ChatKitAdapter({
+        apiKey: process.env.CHATKIT_API_KEY || 'demo-key',
+        ...this.config.config
+      });
+
+      this.initialized = true;
+      this.initTime = new Date();
+      this.errorCount = 0;
+    } catch (error) {
+      this.lastError = error instanceof Error ? error : new Error('Initialization failed');
+      this.errorCount++;
+      throw this.lastError;
+    }
+  }
+
+  /**
+   * Check if provider is initialized
+   */
+  public isInitialized(): boolean {
+    return this.initialized && this.adapter !== undefined;
+  }
+
+  /**
+   * Send a message through ChatKit
+   */
+  public async sendMessage(message: ProviderMessage): Promise<ProviderMessageResult> {
+    if (!this.adapter) {
+      throw new Error('ChatKit adapter not initialized');
+    }
+
+    try {
+      const result = await this.adapter.sendMessage({
+        content: message.content,
+        userId: message.userId,
+        channelId: message.channelId,
+        threadId: message.threadId,
+        attachments: message.attachments?.map(att => ({
+          filename: att.filename,
+          contentType: att.contentType,
+          data: att.data,
+          size: att.size
+        })),
+        metadata: message.metadata
+      });
+
+      if (!result.success) {
+        this.errorCount++;
+        return {
+          success: false,
+          error: result.error,
+          provider: 'chatkit'
+        };
+      }
+
+      return {
+        success: true,
+        messageId: result.messageId,
+        timestamp: result.timestamp ? new Date(result.timestamp) : new Date(),
+        provider: 'chatkit'
+      };
+    } catch (error) {
+      this.lastError = error instanceof Error ? error : new Error('Send message failed');
+      this.errorCount++;
+
+      return {
+        success: false,
+        error: this.lastError.message,
+        provider: 'chatkit'
+      };
+    }
+  }
+
+  /**
+   * Get health status
+   */
+  public async getHealth(): Promise<ProviderHealth> {
+    let status: ProviderHealthStatus = 'unknown';
+    let latency: number | undefined;
+
+    if (!this.initialized || !this.adapter) {
+      status = 'unhealthy';
+    } else {
+      const start = Date.now();
+      try {
+        // Simple health check - attempt to get adapter status
+        const isHealthy = this.adapter !== undefined;
+        latency = Date.now() - start;
+
+        if (isHealthy) {
+          if (this.errorCount === 0) {
+            status = 'healthy';
+          } else if (this.errorCount < 5) {
+            status = 'degraded';
+          } else {
+            status = 'unhealthy';
+          }
+        } else {
+          status = 'unhealthy';
+        }
+      } catch (error) {
+        latency = Date.now() - start;
+        status = 'unhealthy';
+        this.lastError = error instanceof Error ? error : new Error('Health check failed');
+        this.errorCount++;
+      }
+    }
+
+    const uptime = this.initTime ? Date.now() - this.initTime.getTime() : undefined;
+
+    return {
+      status,
+      lastCheck: new Date(),
+      latency,
+      errorCount: this.errorCount,
+      uptime,
+      details: {
+        lastError: this.lastError?.message,
+        features: this.config.features
+      }
+    };
+  }
+
+  /**
+   * Shutdown the provider
+   */
+  public async shutdown(): Promise<void> {
+    this.initialized = false;
+    this.adapter = undefined;
+  }
+
+  /**
+   * Get adapter instance (for advanced usage)
+   */
+  public getAdapter(): ChatKitAdapter | undefined {
+    return this.adapter;
+  }
+
+  /**
+   * Reset error count
+   */
+  public resetErrorCount(): void {
+    this.errorCount = 0;
+    this.lastError = undefined;
+  }
+}