newo 3.3.3 → 3.4.1

package/src/domain/strategies/sync/ConversationSyncStrategy.ts

@@ -0,0 +1,299 @@
+/**
+ * ConversationSyncStrategy - Handles synchronization of Conversation history
+ *
+ * This strategy implements ISyncStrategy for the Conversations resource.
+ * Note: This is a pull-only strategy as conversations are read-only.
+ *
+ * Key responsibilities:
+ * - Pull conversation history from NEWO platform
+ * - Process user personas and their acts
+ * - Save conversations to YAML format
+ */
+
+import type {
+  ISyncStrategy,
+  PullOptions,
+  PullResult,
+  PushResult,
+  ChangeItem,
+  ValidationResult,
+  StatusSummary
+} from './ISyncStrategy.js';
+import type { CustomerConfig, ILogger, HashStore } from '../../resources/common/types.js';
+import type { AxiosInstance } from 'axios';
+import type {
+  UserPersona,
+  ConversationAct,
+  ProcessedPersona,
+  ProcessedAct
+} from '../../../types.js';
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import path from 'path';
+import pLimit from 'p-limit';
+import { listUserPersonas, getChatHistory } from '../../../api.js';
+import { sha256, saveHashes, loadHashes } from '../../../hash.js';
+
+// Concurrency limit for API calls
+const concurrencyLimit = pLimit(5);
+
+/**
+ * Local conversation data for storage
+ */
+export interface LocalConversationData {
+  personas: ProcessedPersona[];
+  totalActs: number;
+}
+
+/**
+ * API client factory type
+ */
+export type ApiClientFactory = (customer: CustomerConfig, verbose: boolean) => Promise<AxiosInstance>;
+
+/**
+ * ConversationSyncStrategy - Handles conversation synchronization
+ */
+export class ConversationSyncStrategy implements ISyncStrategy<UserPersona, LocalConversationData> {
+  readonly resourceType = 'conversations';
+  readonly displayName = 'Conversations';
+
+  constructor(
+    private apiClientFactory: ApiClientFactory,
+    private logger: ILogger
+  ) {}
+
+  /**
+   * Pull all conversations from NEWO platform
+   */
+  async pull(customer: CustomerConfig, options: PullOptions = {}): Promise<PullResult<LocalConversationData>> {
+    const client = await this.apiClientFactory(customer, options.verbose ?? false);
+    const hashes: HashStore = {};
+
+    this.logger.verbose(`💬 Fetching conversations for ${customer.idn}...`);
+
+    const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+    await fs.ensureDir(customerDir);
+
+    // Get all user personas with pagination
+    const allPersonas: UserPersona[] = [];
+    let page = 1;
+    const perPage = 50;
+    let hasMore = true;
+
+    while (hasMore) {
+      const response = await listUserPersonas(client, page, perPage);
+      allPersonas.push(...response.items);
+
+      this.logger.verbose(`  📋 Page ${page}: Found ${response.items.length} personas (${allPersonas.length}/${response.metadata.total} total)`);
+
+      hasMore = response.items.length === perPage && allPersonas.length < response.metadata.total;
+      page++;
+    }
+
+    this.logger.verbose(`👥 Processing ${allPersonas.length} personas...`);
+
+    // Process personas concurrently with limited concurrency
+    const processedPersonas: ProcessedPersona[] = [];
+    let totalActs = 0;
+
+    await Promise.all(allPersonas.map(persona => concurrencyLimit(async () => {
+      try {
+        // Extract phone number from actors
+        const phoneActor = persona.actors.find(actor =>
+          actor.integration_idn === 'newo_voice' &&
+          actor.connector_idn === 'newo_voice_connector' &&
+          actor.contact_information?.startsWith('+')
+        );
+        const phone = phoneActor?.contact_information || null;
+
+        // Get user actor IDs from persona actors
+        const userActors = persona.actors.filter(actor =>
+          actor.integration_idn === 'newo_voice' &&
+          actor.connector_idn === 'newo_voice_connector'
+        );
+
+        if (userActors.length === 0) {
+          processedPersonas.push({
+            id: persona.id,
+            name: persona.name,
+            phone,
+            act_count: persona.act_count,
+            acts: []
+          });
+          return;
+        }
+
+        // Fetch chat history
+        const allActs: ConversationAct[] = [];
+        let actPage = 1;
+        const actsPerPage = 100;
+        let hasMoreActs = true;
+        const maxPages = 50;
+
+        while (hasMoreActs && actPage <= maxPages) {
+          try {
+            const chatHistoryParams = {
+              user_actor_id: userActors[0]!.id,
+              page: actPage,
+              per: actsPerPage
+            };
+
+            const chatResponse = await getChatHistory(client, chatHistoryParams);
+
+            if (chatResponse.items && chatResponse.items.length > 0) {
+              const convertedActs: ConversationAct[] = chatResponse.items.map((item: Record<string, unknown>) => ({
+                id: (item.id as string) || `chat_${Math.random()}`,
+                command_act_id: null,
+                external_event_id: (item.external_event_id as string) || 'chat_history',
+                arguments: [],
+                reference_idn: item.is_agent === true ? 'agent_message' : 'user_message',
+                runtime_context_id: (item.runtime_context_id as string) || 'chat_history',
+                source_text: (item.payload as Record<string, unknown>)?.text as string || (item.message as string) || '',
+                original_text: (item.payload as Record<string, unknown>)?.text as string || (item.message as string) || '',
+                datetime: (item.datetime as string) || (item.created_at as string) || new Date().toISOString(),
+                user_actor_id: userActors[0]!.id,
+                agent_actor_id: null,
+                user_persona_id: persona.id,
+                user_persona_name: persona.name,
+                agent_persona_id: (item.agent_persona_id as string) || 'unknown',
+                external_id: (item.external_id as string) || null,
+                integration_idn: 'newo_voice',
+                connector_idn: 'newo_voice_connector',
+                to_integration_idn: null,
+                to_connector_idn: null,
+                is_agent: Boolean(item.is_agent === true),
+                project_idn: null,
+                flow_idn: (item.flow_idn as string) || 'unknown',
+                skill_idn: (item.skill_idn as string) || 'unknown',
+                session_id: (item.session_id as string) || 'unknown',
+                recordings: (item.recordings as unknown[]) || [],
+                contact_information: (item.contact_information as string) || null
+              }));
+
+              allActs.push(...convertedActs);
+
+              hasMoreActs = chatResponse.items.length === actsPerPage &&
+                           (!chatResponse.metadata?.total || allActs.length < chatResponse.metadata.total);
+              actPage++;
+            } else {
+              hasMoreActs = false;
+            }
+          } catch (_error) {
+            hasMoreActs = false;
+          }
+        }
+
+        // Process acts for YAML output
+        const processedActs: ProcessedAct[] = allActs
+          .sort((a, b) => new Date(a.datetime).getTime() - new Date(b.datetime).getTime())
+          .map(act => ({
+            datetime: act.datetime,
+            type: act.is_agent ? 'agent' : 'user',
+            message: act.source_text,
+            contact_information: act.contact_information,
+            flow_idn: act.flow_idn,
+            skill_idn: act.skill_idn,
+            session_id: act.session_id
+          }));
+
+        processedPersonas.push({
+          id: persona.id,
+          name: persona.name,
+          phone,
+          act_count: persona.act_count,
+          acts: processedActs
+        });
+
+        totalActs += processedActs.length;
+
+        this.logger.verbose(`  ✓ Processed ${persona.name}: ${processedActs.length} acts`);
+      } catch (error) {
+        this.logger.warn(`Failed to process persona ${persona.name}`);
+      }
+    })));
+
+    // Sort personas by most recent activity
+    processedPersonas.sort((a, b) => {
+      const aLastAct = a.acts[a.acts.length - 1]?.datetime;
+      const bLastAct = b.acts[b.acts.length - 1]?.datetime;
+      if (!aLastAct && !bLastAct) return 0;
+      if (!aLastAct) return 1;
+      if (!bLastAct) return -1;
+      return new Date(bLastAct).getTime() - new Date(aLastAct).getTime();
+    });
+
+    // Save to YAML
+    const conversationsFile = path.join(customerDir, 'conversations.yaml');
+    const yamlContent = yaml.dump({ personas: processedPersonas }, { lineWidth: -1 });
+    await fs.writeFile(conversationsFile, yamlContent);
+
+    hashes[conversationsFile] = sha256(yamlContent);
+
+    // Save hashes
+    const existingHashes = await loadHashes(customer.idn);
+    await saveHashes({ ...existingHashes, ...hashes }, customer.idn);
+
+    this.logger.info(`✅ Saved ${processedPersonas.length} personas with ${totalActs} conversation acts`);
+
+    return {
+      items: [{
+        personas: processedPersonas,
+        totalActs
+      }],
+      count: 1,
+      hashes
+    };
+  }
+
+  /**
+   * Push is not supported for conversations (read-only)
+   */
+  async push(_customer: CustomerConfig, _changes?: ChangeItem<LocalConversationData>[]): Promise<PushResult> {
+    this.logger.warn('Conversations are read-only and cannot be pushed');
+    return { created: 0, updated: 0, deleted: 0, errors: ['Conversations are read-only'] };
+  }
+
+  /**
+   * Get changes - conversations are typically regenerated on each pull
+   */
+  async getChanges(_customer: CustomerConfig): Promise<ChangeItem<LocalConversationData>[]> {
+    // Conversations don't support change detection in the traditional sense
+    // They are regenerated on each pull
+    return [];
+  }
+
+  /**
+   * Validate conversation data
+   */
+  async validate(_customer: CustomerConfig, _items: LocalConversationData[]): Promise<ValidationResult> {
+    // Conversations are read-only, no validation needed
+    return { valid: true, errors: [] };
+  }
+
+  /**
+   * Get status summary
+   */
+  async getStatus(customer: CustomerConfig): Promise<StatusSummary> {
+    const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+    const conversationsFile = path.join(customerDir, 'conversations.yaml');
+
+    const exists = await fs.pathExists(conversationsFile);
+
+    return {
+      resourceType: this.resourceType,
+      displayName: this.displayName,
+      changedCount: 0,
+      changes: exists ? [] : [{ path: conversationsFile, operation: 'created' }]
+    };
+  }
+}
+
+/**
+ * Factory function for creating ConversationSyncStrategy
+ */
+export function createConversationSyncStrategy(
+  apiClientFactory: ApiClientFactory,
+  logger: ILogger
+): ConversationSyncStrategy {
+  return new ConversationSyncStrategy(apiClientFactory, logger);
+}

package/src/domain/strategies/sync/ISyncStrategy.ts

@@ -0,0 +1,182 @@
+/**
+ * Generic Sync Strategy Interface
+ *
+ * All resource types (Projects, Integrations, AKB, Attributes) implement this interface.
+ * This enables the SyncEngine to handle all resources uniformly.
+ */
+
+import type { CustomerConfig } from '../../resources/common/types.js';
+
+/**
+ * Validation result for pre-sync validation
+ */
+export interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+}
+
+export interface ValidationError {
+  field: string;
+  message: string;
+  path?: string;
+}
+
+/**
+ * Change operation types
+ */
+export type ChangeOperation = 'created' | 'modified' | 'deleted';
+
+/**
+ * Generic change item representing a resource change
+ */
+export interface ChangeItem<T = unknown> {
+  item: T;
+  operation: ChangeOperation;
+  path: string;
+}
+
+/**
+ * Pull result containing resources and metadata
+ */
+export interface PullResult<T = unknown> {
+  items: T[];
+  count: number;
+  hashes: Record<string, string>;
+}
+
+/**
+ * Push result containing operation outcomes
+ */
+export interface PushResult {
+  created: number;
+  updated: number;
+  deleted: number;
+  errors: string[];
+}
+
+/**
+ * Generic Sync Strategy Interface
+ *
+ * TRemote - Type from the API (e.g., API response types)
+ * TLocal - Type for local storage (e.g., YAML/JSON file types)
+ */
+export interface ISyncStrategy<_TRemote = unknown, TLocal = unknown> {
+  /**
+   * Resource type identifier (e.g., 'projects', 'integrations', 'akb', 'attributes')
+   */
+  readonly resourceType: string;
+
+  /**
+   * Display name for logging/UI (e.g., 'Projects', 'Integrations')
+   */
+  readonly displayName: string;
+
+  /**
+   * Pull resources from NEWO platform to local filesystem
+   *
+   * @param customer - Customer configuration
+   * @param options - Optional pull options
+   * @returns Pull result with items and hashes
+   */
+  pull(customer: CustomerConfig, options?: PullOptions): Promise<PullResult<TLocal>>;
+
+  /**
+   * Push local changes to NEWO platform
+   *
+   * @param customer - Customer configuration
+   * @param changes - Changes to push (if not provided, detect changes automatically)
+   * @returns Push result with counts
+   */
+  push(customer: CustomerConfig, changes?: ChangeItem<TLocal>[]): Promise<PushResult>;
+
+  /**
+   * Detect what has changed locally since last sync
+   *
+   * @param customer - Customer configuration
+   * @returns Array of changed items
+   */
+  getChanges(customer: CustomerConfig): Promise<ChangeItem<TLocal>[]>;
+
+  /**
+   * Validate local state before push
+   *
+   * @param customer - Customer configuration
+   * @param items - Items to validate
+   * @returns Validation result
+   */
+  validate(customer: CustomerConfig, items: TLocal[]): Promise<ValidationResult>;
+
+  /**
+   * Get status summary for display
+   *
+   * @param customer - Customer configuration
+   * @returns Status summary
+   */
+  getStatus(customer: CustomerConfig): Promise<StatusSummary>;
+}
+
+/**
+ * Pull operation options
+ */
+export interface PullOptions {
+  /**
+   * Overwrite local changes without prompting
+   */
+  silentOverwrite?: boolean;
+
+  /**
+   * Enable verbose logging
+   */
+  verbose?: boolean;
+
+  /**
+   * Specific project ID to pull (for projects strategy)
+   */
+  projectId?: string | null;
+
+  /**
+   * Skip deletion detection and cleanup
+   */
+  skipCleanup?: boolean;
+}
+
+/**
+ * Status summary for a resource type
+ */
+export interface StatusSummary {
+  resourceType: string;
+  displayName: string;
+  changedCount: number;
+  changes: Array<{
+    path: string;
+    operation: ChangeOperation;
+    details?: string;
+  }>;
+}
+
+/**
+ * Abstract base class with common strategy functionality
+ */
+export abstract class BaseSyncStrategy<TRemote = unknown, TLocal = unknown> implements ISyncStrategy<TRemote, TLocal> {
+  abstract readonly resourceType: string;
+  abstract readonly displayName: string;
+
+  abstract pull(customer: CustomerConfig, options?: PullOptions): Promise<PullResult<TLocal>>;
+  abstract push(customer: CustomerConfig, changes?: ChangeItem<TLocal>[]): Promise<PushResult>;
+  abstract getChanges(customer: CustomerConfig): Promise<ChangeItem<TLocal>[]>;
+  abstract validate(customer: CustomerConfig, items: TLocal[]): Promise<ValidationResult>;
+
+  async getStatus(customer: CustomerConfig): Promise<StatusSummary> {
+    const changes = await this.getChanges(customer);
+
+    return {
+      resourceType: this.resourceType,
+      displayName: this.displayName,
+      changedCount: changes.length,
+      changes: changes.map(c => ({
+        path: c.path,
+        operation: c.operation
+      }))
+    };
+  }
+}