newo 3.4.0 → 3.4.2

package/dist/domain/strategies/sync/AttributeSyncStrategy.js

@@ -0,0 +1,378 @@
+/**
+ * AttributeSyncStrategy - Handles synchronization of Customer and Project Attributes
+ *
+ * This strategy implements ISyncStrategy for the Attributes resource.
+ *
+ * Key responsibilities:
+ * - Pull customer attributes from NEWO platform
+ * - Pull project attributes for all projects
+ * - Push changed attributes back to platform
+ * - Detect changes using stored hashes
+ */
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import path from 'path';
+import { getCustomerAttributes, getProjectAttributes, updateCustomerAttribute, updateProjectAttribute, listProjects } from '../../../api.js';
+import { writeFileSafe, customerAttributesPath, customerAttributesMapPath } from '../../../fsutil.js';
+import { sha256, saveHashes, loadHashes } from '../../../hash.js';
+/**
+ * AttributeSyncStrategy - Handles attribute synchronization
+ */
+export class AttributeSyncStrategy {
+    apiClientFactory;
+    logger;
+    resourceType = 'attributes';
+    displayName = 'Attributes';
+    constructor(apiClientFactory, logger) {
+        this.apiClientFactory = apiClientFactory;
+        this.logger = logger;
+    }
+    /**
+     * Pull all attributes from NEWO platform
+     */
+    async pull(customer, options = {}) {
+        const client = await this.apiClientFactory(customer, options.verbose ?? false);
+        const hashes = {};
+        const items = [];
+        this.logger.verbose(`🔍 Fetching attributes for ${customer.idn}...`);
+        // Pull customer attributes
+        const customerAttrs = await this.pullCustomerAttributes(client, customer, hashes, options);
+        items.push(customerAttrs);
+        // Pull project attributes
+        const projects = await listProjects(client);
+        this.logger.verbose(`📁 Pulling attributes for ${projects.length} projects`);
+        for (const project of projects) {
+            try {
+                const projectAttrs = await this.pullProjectAttributes(client, customer, project.id, project.idn, hashes, options);
+                if (projectAttrs) {
+                    items.push(projectAttrs);
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to pull attributes for project ${project.idn}`);
+            }
+        }
+        // Save hashes
+        const existingHashes = await loadHashes(customer.idn);
+        await saveHashes({ ...existingHashes, ...hashes }, customer.idn);
+        return {
+            items,
+            count: items.length,
+            hashes
+        };
+    }
+    /**
+     * Pull customer attributes
+     */
+    async pullCustomerAttributes(client, customer, hashes, options) {
+        this.logger.verbose(`  📦 Fetching customer attributes...`);
+        const response = await getCustomerAttributes(client, true);
+        const attributes = response.attributes || [];
+        // Create ID mapping
+        const idMapping = {};
+        const cleanAttributes = attributes.map(attr => {
+            if (attr.id) {
+                idMapping[attr.idn] = attr.id;
+            }
+            return this.cleanAttribute(attr);
+        });
+        // Format as YAML
+        const yamlContent = this.formatAttributesYaml(cleanAttributes);
+        // Save files
+        const attributesPath = customerAttributesPath(customer.idn);
+        await writeFileSafe(attributesPath, yamlContent);
+        await writeFileSafe(customerAttributesMapPath(customer.idn), JSON.stringify(idMapping, null, 2));
+        hashes[attributesPath] = sha256(yamlContent);
+        if (options.verbose) {
+            this.logger.info(`  ✓ Saved ${cleanAttributes.length} customer attributes`);
+        }
+        return {
+            type: 'customer',
+            attributes: cleanAttributes,
+            idMapping
+        };
+    }
+    /**
+     * Pull project attributes
+     */
+    async pullProjectAttributes(client, customer, projectId, projectIdn, hashes, options) {
+        try {
+            const response = await getProjectAttributes(client, projectId, true);
+            const attributes = response.attributes || [];
+            if (attributes.length === 0) {
+                return null;
+            }
+            // Create ID mapping
+            const idMapping = {};
+            const cleanAttributes = attributes.map(attr => {
+                if (attr.id) {
+                    idMapping[attr.idn] = attr.id;
+                }
+                return this.cleanAttribute(attr);
+            });
+            // Format as YAML
+            const yamlContent = this.formatAttributesYaml(cleanAttributes);
+            // Save files
+            const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+            const projectDir = path.join(customerDir, 'projects', projectIdn);
+            await fs.ensureDir(projectDir);
+            const attributesFile = path.join(projectDir, 'attributes.yaml');
+            const mapFile = path.join(process.cwd(), '.newo', customer.idn, `project_${projectIdn}_attributes-map.json`);
+            await writeFileSafe(attributesFile, yamlContent);
+            await fs.ensureDir(path.dirname(mapFile));
+            await writeFileSafe(mapFile, JSON.stringify(idMapping, null, 2));
+            hashes[attributesFile] = sha256(yamlContent);
+            if (options.verbose) {
+                this.logger.verbose(`    ✓ Saved ${cleanAttributes.length} attributes for project ${projectIdn}`);
+            }
+            return {
+                type: 'project',
+                projectIdn,
+                attributes: cleanAttributes,
+                idMapping
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Clean an attribute for local storage
+     */
+    cleanAttribute(attr) {
+        let processedValue = attr.value;
+        // Handle JSON string values
+        if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+            try {
+                const parsed = JSON.parse(attr.value);
+                processedValue = JSON.stringify(parsed, null, 0);
+            }
+            catch {
+                processedValue = attr.value;
+            }
+        }
+        return {
+            idn: attr.idn,
+            value: processedValue,
+            title: attr.title || '',
+            description: attr.description || '',
+            group: attr.group || '',
+            is_hidden: attr.is_hidden,
+            possible_values: attr.possible_values || [],
+            value_type: attr.value_type
+        };
+    }
+    /**
+     * Format attributes as YAML
+     */
+    formatAttributesYaml(attributes) {
+        // Add enum placeholders for value_type
+        const attributesWithPlaceholders = attributes.map(attr => ({
+            ...attr,
+            value_type: `__ENUM_PLACEHOLDER_${attr.value_type}__`
+        }));
+        let yamlContent = yaml.dump({ attributes: attributesWithPlaceholders }, {
+            indent: 2,
+            quotingType: '"',
+            forceQuotes: false,
+            lineWidth: 80,
+            noRefs: true,
+            sortKeys: false,
+            flowLevel: -1
+        });
+        // Replace placeholders with enum syntax
+        yamlContent = yamlContent.replace(/__ENUM_PLACEHOLDER_(\w+)__/g, '!enum "AttributeValueTypes.$1"');
+        yamlContent = yamlContent.replace(/\\"/g, '"');
+        return yamlContent;
+    }
+    /**
+     * Push changed attributes to NEWO platform
+     */
+    async push(customer, changes) {
+        const result = { created: 0, updated: 0, deleted: 0, errors: [] };
+        if (!changes) {
+            changes = await this.getChanges(customer);
+        }
+        if (changes.length === 0) {
+            return result;
+        }
+        const client = await this.apiClientFactory(customer, false);
+        for (const change of changes) {
+            try {
+                if (change.item.type === 'customer') {
+                    const updateCount = await this.pushCustomerAttributes(client, customer, change.item);
+                    result.updated += updateCount;
+                }
+                else if (change.item.type === 'project' && change.item.projectIdn) {
+                    const updateCount = await this.pushProjectAttributes(client, customer, change.item.projectIdn, change.item);
+                    result.updated += updateCount;
+                }
+            }
+            catch (error) {
+                result.errors.push(`Failed to push ${change.path}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return result;
+    }
+    /**
+     * Push customer attributes
+     */
+    async pushCustomerAttributes(client, customer, _data) {
+        // Load current attributes from file
+        const attributesFile = customerAttributesPath(customer.idn);
+        const mapFile = customerAttributesMapPath(customer.idn);
+        if (!(await fs.pathExists(attributesFile)) || !(await fs.pathExists(mapFile))) {
+            return 0;
+        }
+        let content = await fs.readFile(attributesFile, 'utf-8');
+        content = content.replace(/!enum "AttributeValueTypes\.(\w+)"/g, '$1');
+        const localData = yaml.load(content);
+        const idMapping = JSON.parse(await fs.readFile(mapFile, 'utf-8'));
+        // Get remote attributes
+        const remoteResponse = await getCustomerAttributes(client, true);
+        const remoteMap = new Map();
+        remoteResponse.attributes.forEach(attr => remoteMap.set(attr.idn, attr));
+        let updatedCount = 0;
+        for (const localAttr of localData.attributes) {
+            const attributeId = idMapping[localAttr.idn];
+            if (!attributeId)
+                continue;
+            const remoteAttr = remoteMap.get(localAttr.idn);
+            if (!remoteAttr)
+                continue;
+            if (String(localAttr.value) !== String(remoteAttr.value)) {
+                await updateCustomerAttribute(client, {
+                    id: attributeId,
+                    ...localAttr
+                });
+                updatedCount++;
+                this.logger.info(`  ✓ Updated customer attribute: ${localAttr.idn}`);
+            }
+        }
+        return updatedCount;
+    }
+    /**
+     * Push project attributes
+     */
+    async pushProjectAttributes(client, customer, projectIdn, _data) {
+        const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+        const attributesFile = path.join(customerDir, 'projects', projectIdn, 'attributes.yaml');
+        const mapFile = path.join(process.cwd(), '.newo', customer.idn, `project_${projectIdn}_attributes-map.json`);
+        if (!(await fs.pathExists(attributesFile)) || !(await fs.pathExists(mapFile))) {
+            return 0;
+        }
+        let content = await fs.readFile(attributesFile, 'utf-8');
+        content = content.replace(/!enum "AttributeValueTypes\.(\w+)"/g, '$1');
+        const localData = yaml.load(content);
+        const idMapping = JSON.parse(await fs.readFile(mapFile, 'utf-8'));
+        // Get project ID from projects list
+        const projects = await listProjects(client);
+        const project = projects.find(p => p.idn === projectIdn);
+        if (!project) {
+            return 0;
+        }
+        // Get remote attributes
+        const remoteResponse = await getProjectAttributes(client, project.id, true);
+        const remoteMap = new Map();
+        remoteResponse.attributes.forEach(attr => remoteMap.set(attr.idn, attr));
+        let updatedCount = 0;
+        for (const localAttr of localData.attributes) {
+            const attributeId = idMapping[localAttr.idn];
+            if (!attributeId)
+                continue;
+            const remoteAttr = remoteMap.get(localAttr.idn);
+            if (!remoteAttr)
+                continue;
+            if (String(localAttr.value) !== String(remoteAttr.value)) {
+                await updateProjectAttribute(client, project.id, {
+                    id: attributeId,
+                    ...localAttr
+                });
+                updatedCount++;
+                this.logger.info(`  ✓ Updated project attribute: ${projectIdn}/${localAttr.idn}`);
+            }
+        }
+        return updatedCount;
+    }
+    /**
+     * Detect changes in attribute files
+     */
+    async getChanges(customer) {
+        const changes = [];
+        const hashes = await loadHashes(customer.idn);
+        // Check customer attributes
+        const customerAttrsPath = customerAttributesPath(customer.idn);
+        if (await fs.pathExists(customerAttrsPath)) {
+            const content = await fs.readFile(customerAttrsPath, 'utf-8');
+            const currentHash = sha256(content);
+            const storedHash = hashes[customerAttrsPath];
+            if (storedHash !== currentHash) {
+                changes.push({
+                    item: { type: 'customer', attributes: [], idMapping: {} },
+                    operation: 'modified',
+                    path: customerAttrsPath
+                });
+            }
+        }
+        // Check project attributes
+        const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn, 'projects');
+        if (await fs.pathExists(customerDir)) {
+            const projectDirs = await fs.readdir(customerDir);
+            for (const projectIdn of projectDirs) {
+                const attributesFile = path.join(customerDir, projectIdn, 'attributes.yaml');
+                if (await fs.pathExists(attributesFile)) {
+                    const content = await fs.readFile(attributesFile, 'utf-8');
+                    const currentHash = sha256(content);
+                    const storedHash = hashes[attributesFile];
+                    if (storedHash !== currentHash) {
+                        changes.push({
+                            item: { type: 'project', projectIdn, attributes: [], idMapping: {} },
+                            operation: 'modified',
+                            path: attributesFile
+                        });
+                    }
+                }
+            }
+        }
+        return changes;
+    }
+    /**
+     * Validate attribute data
+     */
+    async validate(_customer, items) {
+        const errors = [];
+        for (const item of items) {
+            for (const attr of item.attributes) {
+                if (!attr.idn) {
+                    errors.push({
+                        field: 'idn',
+                        message: 'Attribute IDN is required'
+                    });
+                }
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * Get status summary
+     */
+    async getStatus(customer) {
+        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
+            }))
+        };
+    }
+}
+/**
+ * Factory function for creating AttributeSyncStrategy
+ */
+export function createAttributeSyncStrategy(apiClientFactory, logger) {
+    return new AttributeSyncStrategy(apiClientFactory, logger);
+}
+//# sourceMappingURL=AttributeSyncStrategy.js.map

package/dist/domain/strategies/sync/ConversationSyncStrategy.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 } from '../../resources/common/types.js';
+import type { AxiosInstance } from 'axios';
+import type { UserPersona, ProcessedPersona } from '../../../types.js';
+/**
+ * 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 declare class ConversationSyncStrategy implements ISyncStrategy<UserPersona, LocalConversationData> {
+    private apiClientFactory;
+    private logger;
+    readonly resourceType = "conversations";
+    readonly displayName = "Conversations";
+    constructor(apiClientFactory: ApiClientFactory, logger: ILogger);
+    /**
+     * Pull all conversations from NEWO platform
+     */
+    pull(customer: CustomerConfig, options?: PullOptions): Promise<PullResult<LocalConversationData>>;
+    /**
+     * Push is not supported for conversations (read-only)
+     */
+    push(_customer: CustomerConfig, _changes?: ChangeItem<LocalConversationData>[]): Promise<PushResult>;
+    /**
+     * Get changes - conversations are typically regenerated on each pull
+     */
+    getChanges(_customer: CustomerConfig): Promise<ChangeItem<LocalConversationData>[]>;
+    /**
+     * Validate conversation data
+     */
+    validate(_customer: CustomerConfig, _items: LocalConversationData[]): Promise<ValidationResult>;
+    /**
+     * Get status summary
+     */
+    getStatus(customer: CustomerConfig): Promise<StatusSummary>;
+}
+/**
+ * Factory function for creating ConversationSyncStrategy
+ */
+export declare function createConversationSyncStrategy(apiClientFactory: ApiClientFactory, logger: ILogger): ConversationSyncStrategy;
+//# sourceMappingURL=ConversationSyncStrategy.d.ts.map

package/dist/domain/strategies/sync/ConversationSyncStrategy.js

@@ -0,0 +1,232 @@
+/**
+ * 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 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);
+/**
+ * ConversationSyncStrategy - Handles conversation synchronization
+ */
+export class ConversationSyncStrategy {
+    apiClientFactory;
+    logger;
+    resourceType = 'conversations';
+    displayName = 'Conversations';
+    constructor(apiClientFactory, logger) {
+        this.apiClientFactory = apiClientFactory;
+        this.logger = logger;
+    }
+    /**
+     * Pull all conversations from NEWO platform
+     */
+    async pull(customer, options = {}) {
+        const client = await this.apiClientFactory(customer, options.verbose ?? false);
+        const hashes = {};
+        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 = [];
+        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 = [];
+        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 = [];
+                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 = chatResponse.items.map((item) => ({
+                                id: item.id || `chat_${Math.random()}`,
+                                command_act_id: null,
+                                external_event_id: item.external_event_id || 'chat_history',
+                                arguments: [],
+                                reference_idn: item.is_agent === true ? 'agent_message' : 'user_message',
+                                runtime_context_id: item.runtime_context_id || 'chat_history',
+                                source_text: item.payload?.text || item.message || '',
+                                original_text: item.payload?.text || item.message || '',
+                                datetime: item.datetime || item.created_at || 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 || 'unknown',
+                                external_id: item.external_id || 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 || 'unknown',
+                                skill_idn: item.skill_idn || 'unknown',
+                                session_id: item.session_id || 'unknown',
+                                recordings: item.recordings || [],
+                                contact_information: item.contact_information || 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 = 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, _changes) {
+        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) {
+        // Conversations don't support change detection in the traditional sense
+        // They are regenerated on each pull
+        return [];
+    }
+    /**
+     * Validate conversation data
+     */
+    async validate(_customer, _items) {
+        // Conversations are read-only, no validation needed
+        return { valid: true, errors: [] };
+    }
+    /**
+     * Get status summary
+     */
+    async getStatus(customer) {
+        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, logger) {
+    return new ConversationSyncStrategy(apiClientFactory, logger);
+}
+//# sourceMappingURL=ConversationSyncStrategy.js.map