@bernierllc/chat-suite 1.0.0

package/src/types/message-types.ts

@@ -0,0 +1,94 @@
+/*
+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 { ProviderType, ProviderAttachment } from './provider-types';
+
+/**
+ * Message priority levels
+ */
+export enum MessagePriority {
+  LOW = 'low',
+  NORMAL = 'normal',
+  HIGH = 'high',
+  URGENT = 'urgent'
+}
+
+/**
+ * Message status
+ */
+export enum MessageStatus {
+  PENDING = 'pending',
+  ROUTING = 'routing',
+  SENDING = 'sending',
+  SENT = 'sent',
+  FAILED = 'failed',
+  RETRYING = 'retrying'
+}
+
+/**
+ * Orchestrated message that will be routed through the suite
+ */
+export interface OrchestratedMessage {
+  id: string;
+  content: string;
+  userId?: string;
+  channelId?: string;
+  threadId?: string;
+  attachments?: ProviderAttachment[];
+  priority: MessagePriority;
+  status: MessageStatus;
+  targetProviders?: ProviderType[];
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Message routing decision
+ */
+export interface RoutingDecision {
+  provider: ProviderType;
+  confidence: number;
+  reasoning?: string;
+  fallbackProviders?: ProviderType[];
+}
+
+/**
+ * Message broadcast configuration
+ */
+export interface BroadcastConfig {
+  content: string;
+  platforms: ProviderType[];
+  channels?: string[];
+  priority?: MessagePriority;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Message bridge configuration for cross-platform sync
+ */
+export interface MessageBridgeConfig {
+  enabled: boolean;
+  sourceProviders: ProviderType[];
+  targetProviders: ProviderType[];
+  channelMappings?: Map<string, string>;
+  syncReactions?: boolean;
+  syncEdits?: boolean;
+  syncDeletions?: boolean;
+}
+
+/**
+ * Message event data
+ */
+export interface MessageEvent {
+  type: 'message.sent' | 'message.received' | 'message.failed' | 'message.bridged';
+  messageId: string;
+  provider: ProviderType;
+  timestamp: Date;
+  data: Record<string, unknown>;
+}

package/src/types/provider-types.ts

@@ -0,0 +1,116 @@
+/*
+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.
+*/
+
+/**
+ * Provider type identifiers
+ */
+export type ProviderType = 'chatkit' | 'slack' | 'discord' | 'teams';
+
+/**
+ * Provider health status
+ */
+export type ProviderHealthStatus = 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
+
+/**
+ * Provider configuration
+ */
+export interface ProviderConfig {
+  enabled: boolean;
+  priority: number;
+  config: Record<string, unknown>;
+}
+
+/**
+ * Provider health information
+ */
+export interface ProviderHealth {
+  status: ProviderHealthStatus;
+  lastCheck: Date;
+  latency?: number;
+  errorCount: number;
+  uptime?: number;
+  details?: Record<string, unknown>;
+}
+
+/**
+ * Provider interface that all providers must implement
+ */
+export interface Provider {
+  readonly type: ProviderType;
+  readonly name: string;
+
+  /**
+   * Initialize the provider
+   */
+  initialize(): Promise<void>;
+
+  /**
+   * Check if the provider is initialized
+   */
+  isInitialized(): boolean;
+
+  /**
+   * Send a message through this provider
+   */
+  sendMessage(message: ProviderMessage): Promise<ProviderMessageResult>;
+
+  /**
+   * Get health status of this provider
+   */
+  getHealth(): Promise<ProviderHealth>;
+
+  /**
+   * Shutdown the provider
+   */
+  shutdown(): Promise<void>;
+}
+
+/**
+ * Message to be sent through a provider
+ */
+export interface ProviderMessage {
+  content: string;
+  userId?: string;
+  channelId?: string;
+  threadId?: string;
+  attachments?: ProviderAttachment[];
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * File attachment
+ */
+export interface ProviderAttachment {
+  filename: string;
+  contentType: string;
+  data: Buffer | string;
+  size: number;
+}
+
+/**
+ * Result from sending a message
+ */
+export interface ProviderMessageResult {
+  success: boolean;
+  messageId?: string;
+  timestamp?: Date;
+  error?: string;
+  provider: ProviderType;
+}
+
+/**
+ * Provider capabilities
+ */
+export interface ProviderCapabilities {
+  streaming: boolean;
+  attachments: boolean;
+  threads: boolean;
+  reactions: boolean;
+  editing: boolean;
+  deletion: boolean;
+}

package/src/types/suite-types.ts

@@ -0,0 +1,117 @@
+/*
+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 { ProviderType, ProviderConfig } from './provider-types';
+import type { MessageBridgeConfig } from './message-types';
+
+/**
+ * AI routing configuration
+ */
+export interface AIRoutingConfig {
+  enabled: boolean;
+  serviceName?: string;
+  fallbackToHuman?: boolean;
+  intentThreshold?: number;
+}
+
+/**
+ * Analytics configuration
+ */
+export interface AnalyticsConfig {
+  enabled: boolean;
+  serviceName?: string;
+  metricsInterval?: number;
+}
+
+/**
+ * NeverHub capability definition
+ */
+export interface NeverHubCapability {
+  type: string;
+  name: string;
+  version: string;
+}
+
+/**
+ * NeverHub configuration
+ */
+export interface NeverHubConfig {
+  enabled: boolean;
+  serviceName: string;
+  capabilities: NeverHubCapability[];
+  dependencies: string[];
+}
+
+/**
+ * Provider configurations map
+ */
+export interface ProviderConfigs {
+  chatkit?: ProviderConfig;
+  slack?: ProviderConfig;
+  discord?: ProviderConfig;
+  teams?: ProviderConfig;
+}
+
+/**
+ * Complete chat suite configuration
+ */
+export interface ChatSuiteConfig {
+  enabled: boolean;
+  providers: ProviderConfigs;
+  aiRouting?: AIRoutingConfig;
+  analytics?: AnalyticsConfig;
+  neverhub?: NeverHubConfig;
+  messageBridge?: MessageBridgeConfig;
+}
+
+/**
+ * Chat suite health status
+ */
+export interface ChatSuiteHealth {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  providers: Record<ProviderType, {
+    status: string;
+    latency?: number;
+    errorCount: number;
+  }>;
+  aiRouting?: {
+    enabled: boolean;
+    status: string;
+  };
+  analytics?: {
+    enabled: boolean;
+    status: string;
+  };
+  neverhub?: {
+    enabled: boolean;
+    connected: boolean;
+  };
+  timestamp: Date;
+}
+
+/**
+ * Suite initialization result
+ */
+export interface SuiteInitResult {
+  success: boolean;
+  providersInitialized: ProviderType[];
+  providersFailed: ProviderType[];
+  aiRoutingEnabled: boolean;
+  analyticsEnabled: boolean;
+  neverhubConnected: boolean;
+  error?: string;
+}
+
+/**
+ * Suite operation result
+ */
+export interface SuiteResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}

package/src/utils/config-inheritance.ts

@@ -0,0 +1,189 @@
+/*
+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, ProviderConfigs, ProviderConfig } from '../types';
+
+/**
+ * Default provider configuration
+ */
+const DEFAULT_PROVIDER_CONFIG: ProviderConfig = {
+  enabled: false,
+  priority: 999,
+  config: {}
+};
+
+/**
+ * Default chat suite configuration
+ */
+export const DEFAULT_SUITE_CONFIG: ChatSuiteConfig = {
+  enabled: true,
+  providers: {
+    chatkit: {
+      enabled: true,
+      priority: 1,
+      config: {
+        serviceName: 'chatkit-adapter',
+        features: ['streaming', 'attachments', 'threads']
+      }
+    }
+  },
+  aiRouting: {
+    enabled: true,
+    serviceName: 'chat-ai-router',
+    fallbackToHuman: true,
+    intentThreshold: 0.8
+  },
+  analytics: {
+    enabled: true,
+    serviceName: 'chat-analytics',
+    metricsInterval: 60000
+  },
+  neverhub: {
+    enabled: true,
+    serviceName: 'chat-suite',
+    capabilities: [
+      { type: 'chat', name: 'multi-provider-chat', version: '1.0.0' },
+      { type: 'orchestration', name: 'chat-orchestration', version: '1.0.0' },
+      { type: 'ai', name: 'intelligent-routing', version: '1.0.0' }
+    ],
+    dependencies: ['chat-provider-*', 'chat-ai-router', 'chat-analytics']
+  }
+};
+
+/**
+ * Merge configurations with inheritance
+ */
+export function mergeConfigs(
+  baseConfig: ChatSuiteConfig,
+  overrideConfig: Partial<ChatSuiteConfig>
+): ChatSuiteConfig {
+  return {
+    enabled: overrideConfig.enabled ?? baseConfig.enabled,
+    providers: mergeProviderConfigs(baseConfig.providers, overrideConfig.providers),
+    aiRouting: overrideConfig.aiRouting ? {
+      ...baseConfig.aiRouting,
+      ...overrideConfig.aiRouting
+    } : baseConfig.aiRouting,
+    analytics: overrideConfig.analytics ? {
+      ...baseConfig.analytics,
+      ...overrideConfig.analytics
+    } : baseConfig.analytics,
+    neverhub: overrideConfig.neverhub ? {
+      ...baseConfig.neverhub,
+      ...overrideConfig.neverhub
+    } : baseConfig.neverhub,
+    messageBridge: overrideConfig.messageBridge ?? baseConfig.messageBridge
+  };
+}
+
+/**
+ * Merge provider configurations
+ */
+function mergeProviderConfigs(
+  baseProviders: ProviderConfigs,
+  overrideProviders?: Partial<ProviderConfigs>
+): ProviderConfigs {
+  if (!overrideProviders) {
+    return baseProviders;
+  }
+
+  return {
+    chatkit: mergeProviderConfig(baseProviders.chatkit, overrideProviders.chatkit),
+    slack: mergeProviderConfig(baseProviders.slack, overrideProviders.slack),
+    discord: mergeProviderConfig(baseProviders.discord, overrideProviders.discord),
+    teams: mergeProviderConfig(baseProviders.teams, overrideProviders.teams)
+  };
+}
+
+/**
+ * Merge individual provider configuration
+ */
+function mergeProviderConfig(
+  base?: ProviderConfig,
+  override?: ProviderConfig
+): ProviderConfig | undefined {
+  if (!override && !base) {
+    return undefined;
+  }
+
+  const baseConfig = base || DEFAULT_PROVIDER_CONFIG;
+  if (!override) {
+    return baseConfig;
+  }
+
+  return {
+    enabled: override.enabled ?? baseConfig.enabled,
+    priority: override.priority ?? baseConfig.priority,
+    config: {
+      ...baseConfig.config,
+      ...override.config
+    }
+  };
+}
+
+/**
+ * Validate configuration
+ */
+export function validateConfig(config: ChatSuiteConfig): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Check that at least one provider is enabled
+  const enabledProviders = Object.values(config.providers).filter(p => p?.enabled);
+  if (enabledProviders.length === 0) {
+    errors.push('At least one provider must be enabled');
+  }
+
+  // Validate AI routing config
+  if (config.aiRouting?.enabled) {
+    if (!config.aiRouting.serviceName) {
+      errors.push('AI routing service name is required when AI routing is enabled');
+    }
+    if (config.aiRouting.intentThreshold !== undefined &&
+        (config.aiRouting.intentThreshold < 0 || config.aiRouting.intentThreshold > 1)) {
+      errors.push('AI routing intent threshold must be between 0 and 1');
+    }
+  }
+
+  // Validate analytics config
+  if (config.analytics?.enabled && !config.analytics.serviceName) {
+    errors.push('Analytics service name is required when analytics is enabled');
+  }
+
+  // Validate NeverHub config
+  if (config.neverhub?.enabled) {
+    if (!config.neverhub.serviceName) {
+      errors.push('NeverHub service name is required when NeverHub is enabled');
+    }
+    if (!config.neverhub.capabilities || config.neverhub.capabilities.length === 0) {
+      errors.push('NeverHub capabilities are required when NeverHub is enabled');
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Get active providers from configuration
+ */
+export function getActiveProviders(config: ChatSuiteConfig): Array<{ name: string; priority: number }> {
+  const providers: Array<{ name: string; priority: number }> = [];
+
+  Object.entries(config.providers).forEach(([name, providerConfig]) => {
+    if (providerConfig?.enabled) {
+      providers.push({
+        name,
+        priority: providerConfig.priority
+      });
+    }
+  });
+
+  return providers.sort((a, b) => a.priority - b.priority);
+}

package/src/utils/error-handling.ts

@@ -0,0 +1,114 @@
+/*
+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 { SuiteResult } from '../types';
+
+/**
+ * Chat suite error types
+ */
+export enum ChatSuiteErrorType {
+  PROVIDER_ERROR = 'PROVIDER_ERROR',
+  ROUTING_ERROR = 'ROUTING_ERROR',
+  CONFIGURATION_ERROR = 'CONFIGURATION_ERROR',
+  INITIALIZATION_ERROR = 'INITIALIZATION_ERROR',
+  MESSAGE_ERROR = 'MESSAGE_ERROR',
+  NEVERHUB_ERROR = 'NEVERHUB_ERROR'
+}
+
+/**
+ * Custom error class for chat suite errors
+ */
+export class ChatSuiteError extends Error {
+  constructor(
+    public type: ChatSuiteErrorType,
+    message: string,
+    public originalError?: Error
+  ) {
+    super(message);
+    this.name = 'ChatSuiteError';
+    Object.setPrototypeOf(this, ChatSuiteError.prototype);
+  }
+}
+
+/**
+ * Safely execute an async operation and return a SuiteResult
+ */
+export async function safeExecute<T>(
+  operation: () => Promise<T>,
+  errorType: ChatSuiteErrorType = ChatSuiteErrorType.MESSAGE_ERROR
+): Promise<SuiteResult<T>> {
+  try {
+    const data = await operation();
+    return { success: true, data };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+    return {
+      success: false,
+      error: `${errorType}: ${errorMessage}`
+    };
+  }
+}
+
+/**
+ * Retry an operation with exponential backoff
+ */
+export async function retryOperation<T>(
+  operation: () => Promise<T>,
+  maxRetries: number = 3,
+  baseDelay: number = 1000
+): Promise<T> {
+  let lastError: Error | undefined;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error('Unknown error');
+
+      if (attempt < maxRetries) {
+        const delay = baseDelay * Math.pow(2, attempt);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError || new Error('Operation failed after retries');
+}
+
+/**
+ * Create a standardized error message
+ */
+export function formatError(
+  context: string,
+  error: unknown
+): string {
+  if (error instanceof ChatSuiteError) {
+    return `[${context}] ${error.type}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return `[${context}] ${error.message}`;
+  }
+  return `[${context}] Unknown error: ${String(error)}`;
+}
+
+/**
+ * Check if an error is retryable
+ */
+export function isRetryableError(error: unknown): boolean {
+  if (error instanceof ChatSuiteError) {
+    return error.type === ChatSuiteErrorType.PROVIDER_ERROR ||
+           error.type === ChatSuiteErrorType.MESSAGE_ERROR;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    return message.includes('timeout') ||
+           message.includes('network') ||
+           message.includes('unavailable');
+  }
+  return false;
+}

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+/*
+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 './error-handling';
+export * from './config-inheritance';
+export * from './user-mapping';
+export * from './message-bridge';