@contentstack/cli-variants 1.3.2 → 2.0.0-beta

package/src/export/variant-entries.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
-import { FsUtility, sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { FsUtility, sanitizePath, log, handleAndLogError, CLIProgressManager } from '@contentstack/cli-utilities';
+import { PROCESS_NAMES, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 import { APIConfig, AdapterType, ExportConfig } from '../types';
 import VariantAdapter, { VariantHttpClient } from '../utils/variant-api-adapter';
@@ -8,6 +9,12 @@ import VariantAdapter, { VariantHttpClient } from '../utils/variant-api-adapter'
 export default class VariantEntries extends VariantAdapter<VariantHttpClient<ExportConfig>> {
   public entriesDirPath: string;
   public variantEntryBasePath!: string;
+  protected progressManager: CLIProgressManager | null = null;
+  protected parentProgressManager: CLIProgressManager | null = null;
+  public progress: any;
+  private processInitialized: boolean = false;
+  private totalVariantCount: number = 0;
+  private processedVariantCount: number = 0;
 
   constructor(readonly config: ExportConfig) {
     const conf: APIConfig & AdapterType<VariantHttpClient<ExportConfig>, APIConfig> = {
@@ -33,6 +40,39 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
     }
   }
 
+  /**
+   * Set parent progress manager for integration with entries module
+   */
+  public setParentProgressManager(parentProgress: CLIProgressManager): void {
+    this.parentProgressManager = parentProgress;
+    this.progressManager = parentProgress;
+    this.progress = parentProgress;
+  }
+
+  /**
+   * Update progress for a specific item
+   */
+  protected updateProgress(success: boolean, itemName: string, error?: string, processName?: string): void {
+    if (this.progress) {
+      this.progress.tick(success, itemName, error, processName);
+    }
+  }
+
+  /**
+   * Complete the variant entries export process
+   */
+  public completeExport(): void {
+    if (this.processInitialized && this.progress) {
+      this.progress.completeProcess(PROCESS_NAMES.VARIANT_ENTRIES, true);
+      log.success(
+        `Completed export of ${this.totalVariantCount} variant entries across all content types and locales`,
+        this.config.context,
+      );
+    } else if (this.totalVariantCount === 0) {
+      log.info(`No variant entries found for export`, this.config.context);
+    }
+  }
+
   /**
    * This function exports variant entries for a specific content type and locale.
    * @param options - The `exportVariantEntry` function takes in an `options` object with the following
@@ -41,18 +81,27 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
   async exportVariantEntry(options: { locale: string; contentTypeUid: string; entries: Record<string, any>[] }) {
     const variantEntry = this.config.modules.variantEntry;
     const { entries, locale, contentTypeUid: content_type_uid } = options;
-    
-    log.debug(`Starting variant entries export for content type: ${content_type_uid}, locale: ${locale}`, this.config.context);
+
+    log.debug(
+      `Starting variant entries export for content type: ${content_type_uid}, locale: ${locale}`,
+      this.config.context,
+    );
     log.debug(`Processing ${entries.length} entries for variant export`, this.config.context);
-    
+
     log.debug('Initializing variant instance...', this.config.context);
     await this.variantInstance.init();
     log.debug('Variant instance initialized successfully', this.config.context);
-    
+
+    let localVariantCount = 0; // Track variants found in this specific call
+    let processedEntries = 0;
+
     for (let index = 0; index < entries.length; index++) {
       const entry = entries[index];
-      log.debug(`Processing variant entries for entry: ${entry.title} (${entry.uid}) - ${index + 1}/${entries.length}`, this.config.context);
-      
+      log.debug(
+        `Processing variant entries for entry: ${entry.title} (${entry.uid}) - ${index + 1}/${entries.length}`,
+        this.config.context,
+      );
+
       const variantEntryBasePath = join(
         sanitizePath(this.entriesDirPath),
         sanitizePath(content_type_uid),
@@ -61,7 +110,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
         sanitizePath(entry.uid),
       );
       log.debug(`Variant entry base path: ${variantEntryBasePath}`, this.config.context);
-      
+
       const variantEntriesFs = new FsUtility({
         isArray: true,
         keepMetadata: false,
@@ -73,9 +122,38 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
       });
       log.debug('Initialized FsUtility for variant entries', this.config.context);
 
+      let entryHasVariants = false;
+      let variantCount = 0;
+
       const callback = (variantEntries: Record<string, any>[]) => {
-        log.debug(`Callback received ${variantEntries?.length || 0} variant entries for entry: ${entry.uid}`, this.config.context);
+        log.debug(
+          `Callback received ${variantEntries?.length || 0} variant entries for entry: ${entry.uid}`,
+          this.config.context,
+        );
         if (variantEntries?.length) {
+          log.info(`Fetched ${variantEntries.length} variant entries for entry: ${entry.uid}`, this.config.context);
+          entryHasVariants = true;
+          variantCount = variantEntries.length;
+          localVariantCount += variantCount;
+          this.totalVariantCount += variantCount;
+
+          // Initialize progress ONLY when we find the first variants globally (lazy initialization)
+          if (!this.processInitialized && this.progress) {
+            this.progress.addProcess(PROCESS_NAMES.VARIANT_ENTRIES, variantCount);
+            this.progress.startProcess(PROCESS_NAMES.VARIANT_ENTRIES);
+            this.processInitialized = true;
+            log.debug(
+              `Initialized variant entries progress with first batch of ${variantCount} variants`,
+              this.config.context,
+            );
+          }
+
+          // Update total as we discover more variants globally
+          if (this.processInitialized && this.progress) {
+            this.progress.updateProcessTotal(PROCESS_NAMES.VARIANT_ENTRIES, this.totalVariantCount);
+            log.debug(`Updated progress total to: ${this.totalVariantCount}`, this.config.context);
+          }
+
           if (!existsSync(variantEntryBasePath)) {
             log.debug(`Creating directory: ${variantEntryBasePath}`, this.config.context);
             mkdirSync(variantEntryBasePath, { recursive: true });
@@ -96,7 +174,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
           entry_uid: entry.uid,
           locale,
         });
-        
+
         if (existsSync(variantEntryBasePath)) {
           log.debug(`Completing file for entry: ${entry.uid}`, this.config.context);
           variantEntriesFs.completeFile(true);
@@ -107,8 +185,39 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
         } else {
           log.debug(`No variant entries directory created for entry: ${entry.uid}`, this.config.context);
         }
+
+        // After processing this entry, update progress for variants found
+        if (entryHasVariants && this.processInitialized) {
+          // Tick progress for each variant found in this entry
+          for (let i = 0; i < variantCount; i++) {
+            this.processedVariantCount++;
+            this.updateProgress(
+              true,
+              `Exported variant ${this.processedVariantCount}/${this.totalVariantCount} from ${entry.title || entry.uid}`,
+              undefined,
+              PROCESS_NAMES.VARIANT_ENTRIES,
+            );
+          }
+          log.debug(
+            `Processed ${variantCount} variants for entry: ${entry.uid}, total processed: ${this.processedVariantCount}/${this.totalVariantCount}`,
+            this.config.context,
+          );
+        }
+
+        processedEntries++;
       } catch (error) {
         log.debug(`Error occurred while exporting variant entries for entry: ${entry.uid}`, this.config.context);
+
+        // Track progress for failed entry
+        if (this.processInitialized) {
+          this.updateProgress(
+            false,
+            `Failed to export variants for entry: ${entry.title || entry.uid}`,
+            (error as any)?.message || 'Unknown error',
+            PROCESS_NAMES.VARIANT_ENTRIES,
+          );
+        }
+
         handleAndLogError(
           error,
           { ...this.config.context },
@@ -116,7 +225,22 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
         );
       }
     }
-    
-    log.debug(`Completed variant entries export for content type: ${content_type_uid}, locale: ${locale}`, this.config.context);
+
+    if (localVariantCount > 0) {
+      log.success(
+        `Exported ${localVariantCount} variant entries across ${processedEntries} entries for ${content_type_uid}/${locale}`,
+        this.config.context,
+      );
+    } else {
+      log.info(
+        `No variant entries found for content type: ${content_type_uid}, locale: ${locale}`,
+        this.config.context,
+      );
+    }
+
+    log.debug(
+      `Completed variant entries export for content type: ${content_type_uid}, locale: ${locale}. Local variants: ${localVariantCount}, Total variants so far: ${this.totalVariantCount}, Processed entries: ${processedEntries}`,
+      this.config.context,
+    );
   }
 }

package/src/import/attribute.ts

@@ -3,6 +3,7 @@ import { existsSync } from 'fs';
 import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizationAdapter, fsUtil } from '../utils';
 import { APIConfig, AttributeStruct, ImportConfig, LogType } from '../types';
+import { PROCESS_NAMES, MODULE_CONTEXTS, IMPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class Attribute extends PersonalizationAdapter<ImportConfig> {
   private mapperDirPath: string;
@@ -11,15 +12,16 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
   private attributesUidMapper: Record<string, unknown>;
   private personalizeConfig: ImportConfig['modules']['personalize'];
   private attributeConfig: ImportConfig['modules']['personalize']['attributes'];
+  private attributeData: AttributeStruct[];
 
-  constructor(public readonly config: ImportConfig) {   
+  constructor(public readonly config: ImportConfig) {
     const conf: APIConfig = {
       config,
       baseURL: config.modules.personalize.baseURL[config.region.name],
       headers: { 'X-Project-Uid': config.modules.personalize.project_id },
     };
     super(Object.assign(config, conf));
-    
+
     this.personalizeConfig = this.config.modules.personalize;
     this.attributeConfig = this.personalizeConfig.attributes;
     this.mapperDirPath = resolve(
@@ -30,62 +32,116 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
     this.attrMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.attributeConfig.dirName));
     this.attributesUidMapperPath = resolve(sanitizePath(this.attrMapperDirPath), 'uid-mapping.json');
     this.attributesUidMapper = {};
-    this.config.context.module = 'attributes';
+    this.config.context.module = MODULE_CONTEXTS.ATTRIBUTES;
+    this.attributeData = [];
   }
 
   /**
    * The function asynchronously imports attributes from a JSON file and creates them in the system.
    */
-  async import() {  
-    await this.init();
-    await fsUtil.makeDirectory(this.attrMapperDirPath);
-    log.debug(`Created mapper directory: ${this.attrMapperDirPath}`, this.config.context);
-    
-    const { dirName, fileName } = this.attributeConfig;
-    const attributesPath = resolve(
-      sanitizePath(this.config.data),
-      sanitizePath(this.personalizeConfig.dirName),
-      sanitizePath(dirName),
-      sanitizePath(fileName),
-    );
+  async import() {
+    try {
+      log.debug('Starting attributes import...', this.config.context);
+
+      const [canImport, attributesCount] = await this.analyzeAttributes();
+      if (!canImport) {
+        log.info('No attributes found to import', this.config.context);
+        // Still need to mark as complete for parent progress
+        if (this.parentProgressManager) {
+          this.parentProgressManager.tick(true, 'attributes module (no data)', null, PROCESS_NAMES.ATTRIBUTES);
+        }
+        return;
+      }
+
+      // Don't create own progress manager if we have a parent
+      let progress;
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        log.debug('Using parent progress manager for attributes import', this.config.context);
+        this.parentProgressManager.updateProcessTotal(PROCESS_NAMES.ATTRIBUTES, attributesCount);
+
+      } else {
+        progress = this.createSimpleProgress(PROCESS_NAMES.ATTRIBUTES, attributesCount);
+        log.debug('Created standalone progress manager for attributes import', this.config.context);
+      }
+
+      await this.init();
+      await fsUtil.makeDirectory(this.attrMapperDirPath);
+      log.debug(`Created mapper directory: ${this.attrMapperDirPath}`, this.config.context);
+
+      const { dirName, fileName } = this.attributeConfig;
+      log.info(`Processing ${attributesCount} attributes`, this.config.context);
+
+      for (const attribute of this.attributeData) {
+        const { key, name, description, uid } = attribute;
+        if (!this.parentProgressManager) {
+          progress.updateStatus(IMPORT_PROCESS_STATUS[PROCESS_NAMES.ATTRIBUTES].CREATING);
+        }
+        log.debug(`Processing attribute: ${name} - ${attribute.__type}`, this.config.context);
 
-    log.debug(`Checking for attributes file: ${attributesPath}`, this.config.context);
-    
-    if (existsSync(attributesPath)) {
-      try {
-        const attributes = fsUtil.readFile(attributesPath, true) as AttributeStruct[];
-        log.info(`Found ${attributes.length} attributes to import`, this.config.context);
-
-        for (const attribute of attributes) {
-          const { key, name, description, uid } = attribute;
-          log.debug(`Processing attribute: ${name} - ${attribute.__type}`, this.config.context);
-          
-          // skip creating preset attributes, as they are already present in the system
-          if (attribute.__type === 'PRESET') {
-            log.debug(`Skipping preset attribute: ${name}`, this.config.context);
-            continue;
-          }
-          
-          try {
-            log.debug(`Creating custom attribute: ${name}`, this.config.context);
-            const attributeRes = await this.createAttribute({ key, name, description });
-            //map old attribute uid to new attribute uid
-            //mapper file is used to check whether attribute created or not before creating audience
-            this.attributesUidMapper[uid] = attributeRes?.uid ?? '';
-            log.debug(`Created attribute: ${uid} -> ${attributeRes?.uid}`, this.config.context);
-          } catch (error) {
-            handleAndLogError(error, this.config.context, `Failed to create attribute: ${name}`);
-          }
+        // skip creating preset attributes, as they are already present in the system
+        if (attribute.__type === 'PRESET') {
+          log.debug(`Skipping preset attribute: ${name}`, this.config.context);
+          this.updateProgress(true, `attribute: ${name} (preset - skipped)`, undefined, PROCESS_NAMES.ATTRIBUTES);
+          continue;
         }
 
-        fsUtil.writeFile(this.attributesUidMapperPath, this.attributesUidMapper);
-        log.debug(`Saved ${Object.keys(this.attributesUidMapper).length} attribute mappings to: ${this.attributesUidMapperPath}`, this.config.context);
-        log.success('Attributes imported successfully', this.config.context);
-      } catch (error) {
-        handleAndLogError(error, this.config.context);
+        try {
+          log.debug(`Creating custom attribute: ${name}`, this.config.context);
+          const attributeRes = await this.createAttribute({ key, name, description });
+          //map old attribute uid to new attribute uid
+          //mapper file is used to check whether attribute created or not before creating audience
+          this.attributesUidMapper[uid] = attributeRes?.uid ?? '';
+
+          this.updateProgress(true, `attribute: ${name}`, undefined, PROCESS_NAMES.ATTRIBUTES);
+          log.debug(`Created attribute: ${uid} -> ${attributeRes?.uid}`, this.config.context);
+        } catch (error) {
+          this.updateProgress(false, `attribute: ${name}`, (error as any)?.message, PROCESS_NAMES.ATTRIBUTES);
+          handleAndLogError(error, this.config.context, `Failed to create attribute: ${name}`);
+        }
       }
-    } else {
-      log.warn(`Attributes file not found: ${attributesPath}`, this.config.context);
+
+      fsUtil.writeFile(this.attributesUidMapperPath, this.attributesUidMapper);
+      log.debug(`Saved ${Object.keys(this.attributesUidMapper).length} attribute mappings`, this.config.context);
+
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+      log.success(
+        `Attributes imported successfully! Total attributes: ${attributesCount} - personalization enabled`,
+        this.config.context,
+      );
+    } catch (error) {
+      if (!this.parentProgressManager) {
+        this.completeProgress(false, (error as any)?.message || 'Attributes import failed');
+      }
+      handleAndLogError(error, this.config.context);
+      throw error;
     }
   }
+
+  private async analyzeAttributes(): Promise<[boolean, number]> {
+    return this.withLoadingSpinner('ATTRIBUTES: Analyzing import data...', async () => {
+      const { dirName, fileName } = this.attributeConfig;
+      const attributesPath = resolve(
+        sanitizePath(this.config.data),
+        sanitizePath(this.personalizeConfig.dirName),
+        sanitizePath(dirName),
+        sanitizePath(fileName),
+      );
+
+      log.debug(`Checking for attributes file: ${attributesPath}`, this.config.context);
+
+      if (!existsSync(attributesPath)) {
+        log.warn(`Attributes file not found: ${attributesPath}`, this.config.context);
+        return [false, 0];
+      }
+
+      this.attributeData = fsUtil.readFile(attributesPath, true) as AttributeStruct[];
+      const attributesCount = this.attributeData?.length || 0;
+
+      log.debug(`Found ${attributesCount} attributes to import`, this.config.context);
+      return [attributesCount > 0, attributesCount];
+    });
+  }
 }

package/src/import/audiences.ts

@@ -3,6 +3,7 @@ import { existsSync } from 'fs';
 import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { APIConfig, AudienceStruct, ImportConfig } from '../types';
 import { PersonalizationAdapter, fsUtil, lookUpAttributes } from '../utils';
+import { PROCESS_NAMES, MODULE_CONTEXTS, IMPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class Audiences extends PersonalizationAdapter<ImportConfig> {
   private mapperDirPath: string;
@@ -13,15 +14,16 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
   private personalizeConfig: ImportConfig['modules']['personalize'];
   private audienceConfig: ImportConfig['modules']['personalize']['audiences'];
   public attributeConfig: ImportConfig['modules']['personalize']['attributes'];
+  private audiences: AudienceStruct[];
 
-  constructor(public readonly config: ImportConfig ) {  
+  constructor(public readonly config: ImportConfig) {
     const conf: APIConfig = {
       config,
       baseURL: config.modules.personalize.baseURL[config.region.name],
       headers: { 'X-Project-Uid': config.modules.personalize.project_id },
     };
     super(Object.assign(config, conf));
-    
+
     this.personalizeConfig = this.config.modules.personalize;
     this.audienceConfig = this.personalizeConfig.audiences;
     this.attributeConfig = this.personalizeConfig.attributes;
@@ -38,68 +40,122 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
       'uid-mapping.json',
     );
     this.audiencesUidMapper = {};
-    this.config.context.module = 'audiences';
+    this.config.context.module = MODULE_CONTEXTS.AUDIENCES;
+    this.audiences = [];
   }
 
   /**
    * The function asynchronously imports audiences from a JSON file and creates them in the system.
    */
-  async import() {   
-    await this.init();
-    await fsUtil.makeDirectory(this.audienceMapperDirPath);
-    log.debug(`Created mapper directory: ${this.audienceMapperDirPath}`, this.config.context);
-    
-    const { dirName, fileName } = this.audienceConfig;
-    const audiencesPath = resolve(
-      sanitizePath(this.config.data),
-      sanitizePath(this.personalizeConfig.dirName),
-      sanitizePath(dirName),
-      sanitizePath(fileName),
-    );
+  async import() {
+    try {
+      log.debug('Starting audiences import...', this.config.context);
 
-    log.debug(`Checking for audiences file: ${audiencesPath}`, this.config.context);
-    
-    if (existsSync(audiencesPath)) {
-      try {
-        const audiences = fsUtil.readFile(audiencesPath, true) as AudienceStruct[];
-        log.info(`Found ${audiences.length} audiences to import`, this.config.context);
-        
-        const attributesUid = (fsUtil.readFile(this.attributesMapperPath, true) as Record<string, string>) || {};
-        log.debug(`Loaded ${Object.keys(attributesUid).length} attribute mappings for audience processing`, this.config.context);
-
-        for (const audience of audiences) {
-          let { name, definition, description, uid } = audience;
-          log.debug(`Processing audience: ${name} (${uid})`, this.config.context);
-          
-          try {
-            //check whether reference attributes exists or not
-            if (definition.rules?.length) {
-              log.debug(`Processing ${definition.rules.length} definition rules for audience: ${name}`, this.config.context);
-              definition.rules = lookUpAttributes(definition.rules, attributesUid);
-              log.debug(`Processed definition rules, remaining rules: ${definition.rules.length}`, this.config.context);
-            } else {
-              log.debug(`No definition rules found for audience: ${name}`, this.config.context);
-            }
-            
-            log.debug(`Creating audience: ${name}`, this.config.context);
-            const audienceRes = await this.createAudience({ definition, name, description });
-            //map old audience uid to new audience uid
-            //mapper file is used to check whether audience created or not before creating experience
-            this.audiencesUidMapper[uid] = audienceRes?.uid ?? '';
-            log.debug(`Created audience: ${uid} -> ${audienceRes?.uid}`, this.config.context);
-          } catch (error) {
-            handleAndLogError(error, this.config.context, `Failed to create audience: ${name} (${uid})`);
+      const [canImport, audiencesCount] = await this.analyzeAudiences();
+      if (!canImport) {
+        log.info('No audiences found to import', this.config.context);
+        // Still need to mark as complete for parent progress
+        if (this.parentProgressManager) {
+          this.parentProgressManager.tick(true, 'audiences module (no data)', null, PROCESS_NAMES.AUDIENCES);
+        }
+        return;
+      }
+
+      // Don't create own progress manager if we have a parent
+      let progress;
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        log.debug('Using parent progress manager for audiences import', this.config.context);
+        this.parentProgressManager.updateProcessTotal(PROCESS_NAMES.AUDIENCES, audiencesCount);
+      } else {
+        progress = this.createSimpleProgress(PROCESS_NAMES.AUDIENCES, audiencesCount);
+        log.debug('Created standalone progress manager for audiences import', this.config.context);
+      }
+
+      await this.init();
+      await fsUtil.makeDirectory(this.audienceMapperDirPath);
+      log.debug(`Created mapper directory: ${this.audienceMapperDirPath}`, this.config.context);
+
+      const attributesUid = (fsUtil.readFile(this.attributesMapperPath, true) as Record<string, string>) || {};
+      log.debug(
+        `Loaded ${Object.keys(attributesUid).length} attribute mappings for audience processing`,
+        this.config.context,
+      );
+
+      for (const audience of this.audiences) {
+        let { name, definition, description, uid } = audience;
+        if (!this.parentProgressManager) {
+          progress.updateStatus(IMPORT_PROCESS_STATUS[PROCESS_NAMES.AUDIENCES].CREATING);
+        }
+        log.debug(`Processing audience: ${name} (${uid})`, this.config.context);
+
+        try {
+          //check whether reference attributes exists or not
+          if (definition.rules?.length) {
+            log.debug(
+              `Processing ${definition.rules.length} definition rules for audience: ${name}`,
+              this.config.context,
+            );
+            definition.rules = lookUpAttributes(definition.rules, attributesUid);
+            log.debug(`Processed definition rules, remaining rules: ${definition.rules.length}`, this.config.context);
+          } else {
+            log.debug(`No definition rules found for audience: ${name}`, this.config.context);
           }
+
+          log.debug(`Creating audience: ${name}`, this.config.context);
+          const audienceRes = await this.createAudience({ definition, name, description });
+          //map old audience uid to new audience uid
+          //mapper file is used to check whether audience created or not before creating experience
+          this.audiencesUidMapper[uid] = audienceRes?.uid ?? '';
+
+          this.updateProgress(true, `audience: ${name}`, undefined, PROCESS_NAMES.AUDIENCES);
+          log.debug(`Created audience: ${uid} -> ${audienceRes?.uid}`, this.config.context);
+        } catch (error) {
+          this.updateProgress(false, `audience: ${name}`, (error as any)?.message, PROCESS_NAMES.AUDIENCES);
+          handleAndLogError(error, this.config.context, `Failed to create audience: ${name} (${uid})`);
         }
+      }
+
+      fsUtil.writeFile(this.audiencesUidMapperPath, this.audiencesUidMapper);
+      log.debug(`Saved ${Object.keys(this.audiencesUidMapper).length} audience mappings`, this.config.context);
 
-        fsUtil.writeFile(this.audiencesUidMapperPath, this.audiencesUidMapper);
-        log.debug(`Saved ${Object.keys(this.audiencesUidMapper).length} audience mappings to: ${this.audiencesUidMapperPath}`, this.config.context);
-        log.success('Audiences imported successfully', this.config.context);
-      } catch (error) {
-        handleAndLogError(error, this.config.context);
+      // Only complete progress if we own the progress manager (no parent)
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
       }
-    } else {
-      log.warn(`Audiences file not found: ${audiencesPath}`, this.config.context);
+
+      log.success(`Audiences imported successfully! Total audiences: ${audiencesCount}`, this.config.context);
+    } catch (error) {
+      if (!this.parentProgressManager) {
+        this.completeProgress(false, (error as any)?.message || 'Audiences import failed');
+      }
+      handleAndLogError(error, this.config.context);
+      throw error;
     }
   }
+
+  private async analyzeAudiences(): Promise<[boolean, number]> {
+    return this.withLoadingSpinner('AUDIENCES: Analyzing import data...', async () => {
+      const { dirName, fileName } = this.audienceConfig;
+      const audiencesPath = resolve(
+        sanitizePath(this.config.data),
+        sanitizePath(this.personalizeConfig.dirName),
+        sanitizePath(dirName),
+        sanitizePath(fileName),
+      );
+
+      log.debug(`Checking for audiences file: ${audiencesPath}`, this.config.context);
+
+      if (!existsSync(audiencesPath)) {
+        log.warn(`Audiences file not found: ${audiencesPath}`, this.config.context);
+        return [false, 0];
+      }
+
+      this.audiences = fsUtil.readFile(audiencesPath, true) as AudienceStruct[];
+      const audiencesCount = this.audiences?.length || 0;
+
+      log.debug(`Found ${audiencesCount} audiences to import`, this.config.context);
+      return [audiencesCount > 0, audiencesCount];
+    });
+  }
 }