@bernierllc/chat-suite 1.0.0

package/src/providers/ExternalProviders.ts

@@ -0,0 +1,171 @@
+/*
+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 type {
+  Provider,
+  ProviderMessage,
+  ProviderMessageResult,
+  ProviderHealth
+} from '../types';
+
+/**
+ * Base class for external providers (Slack, Discord, Teams)
+ * These are optional peer dependencies and will be implemented when those packages are available
+ */
+abstract class ExternalProvider implements Provider {
+  public abstract readonly type: 'slack' | 'discord' | 'teams';
+  public abstract readonly name: string;
+
+  protected initialized = false;
+
+  public async initialize(): Promise<void> {
+    throw new Error(
+      `${this.name} provider is not implemented yet. ` +
+      `Install ${this.name} package to enable this provider.`
+    );
+  }
+
+  public isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  public async sendMessage(_message: ProviderMessage): Promise<ProviderMessageResult> {
+    throw new Error(
+      `${this.name} provider is not available. ` +
+      `Install ${this.name} package to send messages.`
+    );
+  }
+
+  public async getHealth(): Promise<ProviderHealth> {
+    return {
+      status: 'unknown',
+      lastCheck: new Date(),
+      errorCount: 0,
+      details: {
+        error: `${this.name} provider not installed`
+      }
+    };
+  }
+
+  public async shutdown(): Promise<void> {
+    this.initialized = false;
+  }
+}
+
+/**
+ * Slack provider placeholder
+ *
+ * To enable Slack integration:
+ * 1. Install @bernierllc/chat-integration-slack
+ * 2. Import SlackProvider from that package
+ * 3. Register with the chat suite
+ *
+ * Example:
+ * ```typescript
+ * import { SlackProvider } from '@bernierllc/chat-integration-slack';
+ *
+ * const slackProvider = new SlackProvider({
+ *   token: process.env.SLACK_BOT_TOKEN,
+ *   channels: ['#general', '#dev']
+ * });
+ *
+ * await chatSuite.registerProvider(slackProvider);
+ * ```
+ */
+export class SlackProvider extends ExternalProvider {
+  public readonly type = 'slack' as const;
+  public readonly name = '@bernierllc/chat-integration-slack';
+
+  constructor(_config?: Record<string, unknown>) {
+    super();
+  }
+}
+
+/**
+ * Discord provider placeholder
+ *
+ * To enable Discord integration:
+ * 1. Install @bernierllc/chat-integration-discord
+ * 2. Import DiscordProvider from that package
+ * 3. Register with the chat suite
+ *
+ * Example:
+ * ```typescript
+ * import { DiscordProvider } from '@bernierllc/chat-integration-discord';
+ *
+ * const discordProvider = new DiscordProvider({
+ *   token: process.env.DISCORD_BOT_TOKEN,
+ *   guilds: ['123456789012345678']
+ * });
+ *
+ * await chatSuite.registerProvider(discordProvider);
+ * ```
+ */
+export class DiscordProvider extends ExternalProvider {
+  public readonly type = 'discord' as const;
+  public readonly name = '@bernierllc/chat-integration-discord';
+
+  constructor(_config?: Record<string, unknown>) {
+    super();
+  }
+}
+
+/**
+ * Microsoft Teams provider placeholder
+ *
+ * To enable Teams integration:
+ * 1. Install @bernierllc/chat-integration-teams
+ * 2. Import TeamsProvider from that package
+ * 3. Register with the chat suite
+ *
+ * Example:
+ * ```typescript
+ * import { TeamsProvider } from '@bernierllc/chat-integration-teams';
+ *
+ * const teamsProvider = new TeamsProvider({
+ *   tenantId: process.env.TEAMS_TENANT_ID,
+ *   clientId: process.env.TEAMS_CLIENT_ID,
+ *   clientSecret: process.env.TEAMS_CLIENT_SECRET
+ * });
+ *
+ * await chatSuite.registerProvider(teamsProvider);
+ * ```
+ */
+export class TeamsProvider extends ExternalProvider {
+  public readonly type = 'teams' as const;
+  public readonly name = '@bernierllc/chat-integration-teams';
+
+  constructor(_config?: Record<string, unknown>) {
+    super();
+  }
+}
+
+/**
+ * Check if an external provider package is available
+ */
+export function isProviderAvailable(providerName: string): boolean {
+  try {
+    require.resolve(providerName);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get list of available external providers
+ */
+export function getAvailableProviders(): string[] {
+  const providers = [
+    '@bernierllc/chat-integration-slack',
+    '@bernierllc/chat-integration-discord',
+    '@bernierllc/chat-integration-teams'
+  ];
+
+  return providers.filter(isProviderAvailable);
+}

package/src/providers/index.ts

@@ -0,0 +1,10 @@
+/*
+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 './ChatKitProvider';
+export * from './ExternalProviders';

package/src/services/ConfigManager.ts

@@ -0,0 +1,112 @@
+/*
+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 type { ChatSuiteConfig } from '../types';
+import { DEFAULT_SUITE_CONFIG, mergeConfigs, validateConfig } from '../utils/config-inheritance';
+import { ChatSuiteError, ChatSuiteErrorType } from '../utils/error-handling';
+
+/**
+ * Manages chat suite configuration with validation and inheritance
+ */
+export class ConfigManager {
+  private config: ChatSuiteConfig;
+  private configOverrides: Map<string, unknown> = new Map();
+
+  constructor(initialConfig?: Partial<ChatSuiteConfig>) {
+    this.config = mergeConfigs(DEFAULT_SUITE_CONFIG, initialConfig || {});
+    this.validateConfiguration();
+  }
+
+  /**
+   * Get the current configuration
+   */
+  public getConfig(): Readonly<ChatSuiteConfig> {
+    return this.config;
+  }
+
+  /**
+   * Update configuration
+   */
+  public updateConfig(updates: Partial<ChatSuiteConfig>): void {
+    const newConfig = mergeConfigs(this.config, updates);
+    this.validateConfiguration(newConfig);
+    this.config = newConfig;
+  }
+
+  /**
+   * Get a specific configuration value
+   */
+  public get<K extends keyof ChatSuiteConfig>(key: K): ChatSuiteConfig[K] {
+    return this.config[key];
+  }
+
+  /**
+   * Set a configuration override
+   */
+  public setOverride(key: string, value: unknown): void {
+    this.configOverrides.set(key, value);
+  }
+
+  /**
+   * Get a configuration override
+   */
+  public getOverride(key: string): unknown {
+    return this.configOverrides.get(key);
+  }
+
+  /**
+   * Clear all overrides
+   */
+  public clearOverrides(): void {
+    this.configOverrides.clear();
+  }
+
+  /**
+   * Reset to default configuration
+   */
+  public reset(): void {
+    this.config = { ...DEFAULT_SUITE_CONFIG };
+    this.configOverrides.clear();
+  }
+
+  /**
+   * Validate the current configuration
+   */
+  private validateConfiguration(config: ChatSuiteConfig = this.config): void {
+    const validation = validateConfig(config);
+    if (!validation.valid) {
+      throw new ChatSuiteError(
+        ChatSuiteErrorType.CONFIGURATION_ERROR,
+        `Configuration validation failed: ${validation.errors.join(', ')}`
+      );
+    }
+  }
+
+  /**
+   * Export configuration as JSON
+   */
+  public toJSON(): string {
+    return JSON.stringify(this.config, null, 2);
+  }
+
+  /**
+   * Load configuration from JSON
+   */
+  public fromJSON(json: string): void {
+    try {
+      const parsed = JSON.parse(json) as Partial<ChatSuiteConfig>;
+      this.updateConfig(parsed);
+    } catch (error) {
+      throw new ChatSuiteError(
+        ChatSuiteErrorType.CONFIGURATION_ERROR,
+        'Failed to parse configuration JSON',
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+}

package/src/services/HealthMonitor.ts

@@ -0,0 +1,169 @@
+/*
+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 type { Provider, ProviderType, ChatSuiteHealth } from '../types';
+
+/**
+ * Health check result
+ */
+export interface HealthCheckResult {
+  healthy: boolean;
+  timestamp: Date;
+  details?: Record<string, unknown>;
+}
+
+/**
+ * Monitors health of all chat suite components
+ */
+export class HealthMonitor {
+  private providers: Map<ProviderType, Provider> = new Map();
+  private lastHealthCheck?: Date;
+  private healthCheckInterval?: NodeJS.Timeout;
+
+  /**
+   * Register a provider for health monitoring
+   */
+  public registerProvider(provider: Provider): void {
+    this.providers.set(provider.type, provider);
+  }
+
+  /**
+   * Unregister a provider
+   */
+  public unregisterProvider(providerType: ProviderType): void {
+    this.providers.delete(providerType);
+  }
+
+  /**
+   * Start periodic health checks
+   */
+  public startMonitoring(intervalMs: number = 60000): void {
+    this.stopMonitoring();
+    this.healthCheckInterval = setInterval(() => {
+      void this.checkHealth();
+    }, intervalMs);
+  }
+
+  /**
+   * Stop periodic health checks
+   */
+  public stopMonitoring(): void {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = undefined;
+    }
+  }
+
+  /**
+   * Perform health check on all components
+   */
+  public async checkHealth(): Promise<ChatSuiteHealth> {
+    const timestamp = new Date();
+    this.lastHealthCheck = timestamp;
+
+    const providerStatuses: ChatSuiteHealth['providers'] = {} as ChatSuiteHealth['providers'];
+
+    // Check each provider
+    for (const [type, provider] of this.providers) {
+      try {
+        const health = await provider.getHealth();
+        providerStatuses[type] = {
+          status: health.status,
+          latency: health.latency,
+          errorCount: health.errorCount
+        };
+      } catch (error) {
+        providerStatuses[type] = {
+          status: 'unhealthy',
+          errorCount: 1
+        };
+      }
+    }
+
+    // Determine overall status
+    const statuses = Object.values(providerStatuses).map(p => p.status);
+    let overallStatus: ChatSuiteHealth['status'] = 'healthy';
+
+    if (statuses.some(s => s === 'unhealthy')) {
+      overallStatus = 'unhealthy';
+    } else if (statuses.some(s => s === 'degraded')) {
+      overallStatus = 'degraded';
+    }
+
+    return {
+      status: overallStatus,
+      providers: providerStatuses,
+      timestamp
+    };
+  }
+
+  /**
+   * Get health status for a specific provider
+   */
+  public async checkProviderHealth(providerType: ProviderType): Promise<HealthCheckResult> {
+    const provider = this.providers.get(providerType);
+    if (!provider) {
+      return {
+        healthy: false,
+        timestamp: new Date(),
+        details: { error: 'Provider not registered' }
+      };
+    }
+
+    try {
+      const health = await provider.getHealth();
+      return {
+        healthy: health.status === 'healthy',
+        timestamp: new Date(),
+        details: {
+          status: health.status,
+          latency: health.latency,
+          errorCount: health.errorCount,
+          uptime: health.uptime
+        }
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        timestamp: new Date(),
+        details: {
+          error: error instanceof Error ? error.message : 'Health check failed'
+        }
+      };
+    }
+  }
+
+  /**
+   * Get the last health check timestamp
+   */
+  public getLastCheckTime(): Date | undefined {
+    return this.lastHealthCheck;
+  }
+
+  /**
+   * Get all registered providers
+   */
+  public getRegisteredProviders(): ProviderType[] {
+    return Array.from(this.providers.keys());
+  }
+
+  /**
+   * Check if monitoring is active
+   */
+  public isMonitoring(): boolean {
+    return this.healthCheckInterval !== undefined;
+  }
+
+  /**
+   * Clean up resources
+   */
+  public shutdown(): void {
+    this.stopMonitoring();
+    this.providers.clear();
+  }
+}