@contentstack/cli-audit 1.14.2 → 1.16.0

package/lib/modules/entries.js

@@ -10,11 +10,10 @@ const cli_utilities_1 = require("@contentstack/cli-utilities");
 const fs_1 = require("fs");
 const content_types_1 = tslib_1.__importDefault(require("./content-types"));
 const messages_1 = require("../messages");
-const util_1 = require("../util");
 const global_fields_1 = tslib_1.__importDefault(require("./global-fields"));
 const lodash_1 = require("lodash");
 class Entries {
-    constructor({ log, fix, config, moduleName, ctSchema, gfSchema }) {
+    constructor({ fix, config, moduleName, ctSchema, gfSchema }) {
         this.extensions = [];
         this.missingRefs = {};
         this.missingSelectFeild = {};
@@ -25,19 +24,26 @@ class Entries {
         this.environments = [];
         this.entryMetaData = [];
         this.moduleName = 'entries';
-        this.log = log;
         this.config = config;
+        cli_utilities_1.log.debug(`Initializing Entries module`, this.config.auditContext);
         this.fix = fix !== null && fix !== void 0 ? fix : false;
         this.ctSchema = ctSchema;
         this.gfSchema = gfSchema;
         this.moduleName = this.validateModules(moduleName, this.config.moduleConfig);
         this.fileName = config.moduleConfig[this.moduleName].fileName;
         this.folderPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(config.basePath), (0, cli_utilities_1.sanitizePath)(config.moduleConfig.entries.dirName));
+        cli_utilities_1.log.debug(`Starting ${this.moduleName} audit process`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Data directory: ${this.folderPath}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Fix mode: ${this.fix}`, this.config.auditContext);
     }
     validateModules(moduleName, moduleConfig) {
+        cli_utilities_1.log.debug(`Validating module: ${moduleName}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Available modules in config: ${Object.keys(moduleConfig).join(', ')}`, this.config.auditContext);
         if (Object.keys(moduleConfig).includes(moduleName)) {
+            cli_utilities_1.log.debug(`Module ${moduleName} found in config, returning: ${moduleName}`, this.config.auditContext);
             return moduleName;
         }
+        cli_utilities_1.log.debug(`Module ${moduleName} not found in config, defaulting to: entries`, this.config.auditContext);
         return 'entries';
     }
     /**
@@ -46,22 +52,36 @@ class Entries {
      * @returns the `missingRefs` object.
      */
     async run() {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         if (!(0, fs_1.existsSync)(this.folderPath)) {
-            this.log(`Skipping ${this.moduleName} audit`, 'warn');
-            this.log((0, messages_1.$t)(messages_1.auditMsg.NOT_VALID_PATH, { path: this.folderPath }), { color: 'yellow' });
+            cli_utilities_1.log.debug(`Skipping ${this.moduleName} audit - path does not exist`, this.config.auditContext);
+            cli_utilities_1.log.warn(`Skipping ${this.moduleName} audit`, this.config.auditContext);
+            cli_utilities_1.cliux.print((0, messages_1.$t)(messages_1.auditMsg.NOT_VALID_PATH, { path: this.folderPath }), { color: 'yellow' });
             return {};
         }
+        cli_utilities_1.log.debug(`Found ${((_a = this.ctSchema) === null || _a === void 0 ? void 0 : _a.length) || 0} content types to audit`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Found ${((_b = this.locales) === null || _b === void 0 ? void 0 : _b.length) || 0} locales to process`, this.config.auditContext);
+        cli_utilities_1.log.debug('Preparing entry metadata', this.config.auditContext);
         await this.prepareEntryMetaData();
+        cli_utilities_1.log.debug(`Entry metadata prepared: ${this.entryMetaData.length} entries found`, this.config.auditContext);
+        cli_utilities_1.log.debug('Fixing prerequisite data', this.config.auditContext);
         await this.fixPrerequisiteData();
+        cli_utilities_1.log.debug('Prerequisite data fix completed', this.config.auditContext);
+        cli_utilities_1.log.debug(`Processing ${this.locales.length} locales and ${this.ctSchema.length} content types`, this.config.auditContext);
         for (const { code } of this.locales) {
+            cli_utilities_1.log.debug(`Processing locale: ${code}`, this.config.auditContext);
             for (const ctSchema of this.ctSchema) {
+                cli_utilities_1.log.debug(`Processing content type: ${ctSchema.uid} in locale ${code}`, this.config.auditContext);
                 const basePath = (0, path_1.join)(this.folderPath, ctSchema.uid, code);
+                cli_utilities_1.log.debug(`Base path for entries: ${basePath}`, this.config.auditContext);
                 const fsUtility = new cli_utilities_1.FsUtility({ basePath, indexFileName: 'index.json', createDirIfNotExist: false });
                 const indexer = fsUtility.indexFileContent;
+                cli_utilities_1.log.debug(`Found ${Object.keys(indexer).length} entry files to process`, this.config.auditContext);
                 for (const fileIndex in indexer) {
+                    cli_utilities_1.log.debug(`Processing entry file: ${indexer[fileIndex]}`, this.config.auditContext);
                     const entries = (await fsUtility.readChunkFiles.next());
                     this.entries = entries;
+                    cli_utilities_1.log.debug(`Loaded ${Object.keys(entries).length} entries from file`, this.config.auditContext);
                     for (const entryUid in this.entries) {
                         const entry = this.entries[entryUid];
                         const { uid, title } = entry;
@@ -70,6 +90,7 @@ class Entries {
                         if (this.currentTitle) {
                             this.currentTitle = this.removeEmojiAndImages(this.currentTitle);
                         }
+                        cli_utilities_1.log.debug(`Processing entry - title:${this.currentTitle} with uid:(${uid})`, this.config.auditContext);
                         if (!this.missingRefs[this.currentUid]) {
                             this.missingRefs[this.currentUid] = [];
                         }
@@ -80,39 +101,49 @@ class Entries {
                             this.missingMandatoryFields[this.currentUid] = [];
                         }
                         if (this.fix) {
+                            cli_utilities_1.log.debug(`Removing missing keys from entry ${uid}`, this.config.auditContext);
                             this.removeMissingKeysOnEntry(ctSchema.schema, this.entries[entryUid]);
                         }
+                        cli_utilities_1.log.debug(`Looking for references in entry ${uid}`, this.config.auditContext);
                         this.lookForReference([{ locale: code, uid, name: this.removeEmojiAndImages(this.currentTitle) }], ctSchema, this.entries[entryUid]);
-                        if ((_a = this.missingRefs[this.currentUid]) === null || _a === void 0 ? void 0 : _a.length) {
+                        if ((_c = this.missingRefs[this.currentUid]) === null || _c === void 0 ? void 0 : _c.length) {
+                            cli_utilities_1.log.debug(`Found ${this.missingRefs[this.currentUid].length} missing references for entry ${uid}`, this.config.auditContext);
                             this.missingRefs[this.currentUid].forEach((entry) => {
                                 entry.ct = ctSchema.uid;
                                 entry.locale = code;
                             });
                         }
-                        if ((_b = this.missingSelectFeild[this.currentUid]) === null || _b === void 0 ? void 0 : _b.length) {
+                        if ((_d = this.missingSelectFeild[this.currentUid]) === null || _d === void 0 ? void 0 : _d.length) {
+                            cli_utilities_1.log.debug(`Found ${this.missingSelectFeild[this.currentUid].length} missing select fields for entry ${uid}`, this.config.auditContext);
                             this.missingSelectFeild[this.currentUid].forEach((entry) => {
                                 entry.ct = ctSchema.uid;
                                 entry.locale = code;
                             });
                         }
-                        if ((_c = this.missingMandatoryFields[this.currentUid]) === null || _c === void 0 ? void 0 : _c.length) {
+                        if ((_e = this.missingMandatoryFields[this.currentUid]) === null || _e === void 0 ? void 0 : _e.length) {
+                            cli_utilities_1.log.debug(`Found ${this.missingMandatoryFields[this.currentUid].length} missing mandatory fields for entry ${uid}`, this.config.auditContext);
                             this.missingMandatoryFields[this.currentUid].forEach((entry) => {
                                 entry.ct = ctSchema.uid;
                                 entry.locale = code;
                             });
                         }
                         const fields = this.missingMandatoryFields[uid];
-                        const isPublished = ((_d = entry.publish_details) === null || _d === void 0 ? void 0 : _d.length) > 0;
+                        const isPublished = ((_f = entry.publish_details) === null || _f === void 0 ? void 0 : _f.length) > 0;
+                        cli_utilities_1.log.debug(`Entry ${uid} published status: ${isPublished}, missing mandatory fields: ${(fields === null || fields === void 0 ? void 0 : fields.length) || 0}`, this.config.auditContext);
                         if ((this.fix && fields.length && isPublished) || (!this.fix && fields)) {
                             const fixStatus = this.fix ? 'Fixed' : '';
-                            fields === null || fields === void 0 ? void 0 : fields.forEach((field) => {
+                            cli_utilities_1.log.debug(`Applying fix status: ${fixStatus} to ${fields.length} fields`, this.config.auditContext);
+                            fields === null || fields === void 0 ? void 0 : fields.forEach((field, index) => {
+                                cli_utilities_1.log.debug(`Processing field ${index + 1}/${fields.length}`, this.config.auditContext);
                                 field.isPublished = isPublished;
                                 if (this.fix && isPublished) {
                                     field.fixStatus = fixStatus;
+                                    cli_utilities_1.log.debug(`Field ${index + 1} marked as published and fixed`, this.config.auditContext);
                                 }
                             });
                             if (this.fix && isPublished) {
-                                this.log((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_MANDATORY_FIELD_FIX, { uid, locale: code }), 'error');
+                                cli_utilities_1.log.debug(`Fixing mandatory field issue for entry ${uid}`, this.config.auditContext);
+                                cli_utilities_1.log.error((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_MANDATORY_FIELD_FIX, { uid, locale: code }), this.config.auditContext);
                                 entry.publish_details = [];
                             }
                         }
@@ -120,23 +151,30 @@ class Entries {
                             delete this.missingMandatoryFields[uid];
                         }
                         const localKey = this.locales.map((locale) => locale.code);
-                        if (((_e = this.entries[entryUid]) === null || _e === void 0 ? void 0 : _e.publish_details) && !Array.isArray(this.entries[entryUid].publish_details)) {
-                            this.log((0, messages_1.$t)(messages_1.auditMsg.ENTRY_PUBLISH_DETAILS_NOT_EXIST, { uid: entryUid }), { color: 'red' });
+                        cli_utilities_1.log.debug(`Available locales: ${localKey.join(', ')}, environments: ${this.environments.join(', ')}`, this.config.auditContext);
+                        if (((_g = this.entries[entryUid]) === null || _g === void 0 ? void 0 : _g.publish_details) && !Array.isArray(this.entries[entryUid].publish_details)) {
+                            cli_utilities_1.log.debug(`Entry ${entryUid} has invalid publish_details format`, this.config.auditContext);
+                            cli_utilities_1.log.debug((0, messages_1.$t)(messages_1.auditMsg.ENTRY_PUBLISH_DETAILS_NOT_EXIST, { uid: entryUid }), this.config.auditContext);
                         }
-                        this.entries[entryUid].publish_details = (_f = this.entries[entryUid]) === null || _f === void 0 ? void 0 : _f.publish_details.filter((pd) => {
+                        const originalPublishDetails = ((_j = (_h = this.entries[entryUid]) === null || _h === void 0 ? void 0 : _h.publish_details) === null || _j === void 0 ? void 0 : _j.length) || 0;
+                        this.entries[entryUid].publish_details = (_k = this.entries[entryUid]) === null || _k === void 0 ? void 0 : _k.publish_details.filter((pd) => {
                             var _a;
+                            cli_utilities_1.log.debug(`Checking publish detail: locale=${pd.locale}, environment=${pd.environment}`, this.config.auditContext);
                             if ((localKey === null || localKey === void 0 ? void 0 : localKey.includes(pd.locale)) && ((_a = this.environments) === null || _a === void 0 ? void 0 : _a.includes(pd.environment))) {
+                                cli_utilities_1.log.debug(`Publish detail valid for entry ${entryUid}: locale=${pd.locale}, environment=${pd.environment}`, this.config.auditContext);
                                 return true;
                             }
                             else {
-                                this.log((0, messages_1.$t)(messages_1.auditMsg.ENTRY_PUBLISH_DETAILS, {
+                                cli_utilities_1.log.debug(`Publish detail invalid for entry ${entryUid}: locale=${pd.locale}, environment=${pd.environment}`, this.config.auditContext);
+                                cli_utilities_1.log.debug((0, messages_1.$t)(messages_1.auditMsg.ENTRY_PUBLISH_DETAILS, {
                                     uid: entryUid,
                                     ctuid: ctSchema.uid,
                                     locale: code,
                                     publocale: pd.locale,
                                     environment: pd.environment,
-                                }), { color: 'red' });
+                                }), this.config.auditContext);
                                 if (!Object.keys(this.missingEnvLocale).includes(entryUid)) {
+                                    cli_utilities_1.log.debug(`Creating new missing environment/locale entry for ${entryUid}`, this.config.auditContext);
                                     this.missingEnvLocale[entryUid] = [
                                         {
                                             entry_uid: entryUid,
@@ -148,6 +186,7 @@ class Entries {
                                     ];
                                 }
                                 else {
+                                    cli_utilities_1.log.debug(`Adding to existing missing environment/locale entry for ${entryUid}`, this.config.auditContext);
                                     this.missingEnvLocale[entryUid].push({
                                         entry_uid: entryUid,
                                         publish_locale: pd.locale,
@@ -159,23 +198,26 @@ class Entries {
                                 return false;
                             }
                         });
+                        const remainingPublishDetails = ((_l = this.entries[entryUid].publish_details) === null || _l === void 0 ? void 0 : _l.length) || 0;
+                        cli_utilities_1.log.debug(`Entry ${entryUid} publish details: ${originalPublishDetails} -> ${remainingPublishDetails}`, this.config.auditContext);
                         const message = (0, messages_1.$t)(messages_1.auditMsg.SCAN_ENTRY_SUCCESS_MSG, {
                             title,
                             local: code,
                             module: this.config.moduleConfig.entries.name,
                         });
-                        this.log(message, 'hidden');
-                        (0, util_1.print)([{ message: `info: ${message}`, color: 'green' }]);
+                        cli_utilities_1.log.debug(message, this.config.auditContext);
+                        cli_utilities_1.log.info(message, this.config.auditContext);
                     }
                     if (this.fix) {
+                        cli_utilities_1.log.debug(`Writing fix content for ${Object.keys(this.entries).length} entries`, this.config.auditContext);
                         await this.writeFixContent(`${basePath}/${indexer[fileIndex]}`, this.entries);
                     }
                 }
             }
         }
-        // this.log('', 'info'); // Adding empty line
+        cli_utilities_1.log.debug('Cleaning up empty missing references', this.config.auditContext);
         this.removeEmptyVal();
-        return {
+        const result = {
             missingEntryRefs: this.missingRefs,
             missingSelectFeild: this.missingSelectFeild,
             missingMandatoryFields: this.missingMandatoryFields,
@@ -183,67 +225,106 @@ class Entries {
             missingEnvLocale: this.missingEnvLocale,
             missingMultipleFields: this.missingMultipleField,
         };
+        cli_utilities_1.log.debug(`Entries audit completed. Found issues:`, this.config.auditContext);
+        cli_utilities_1.log.debug(`- Missing references: ${Object.keys(this.missingRefs).length}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`- Missing select fields: ${Object.keys(this.missingSelectFeild).length}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`- Missing mandatory fields: ${Object.keys(this.missingMandatoryFields).length}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`- Missing title fields: ${Object.keys(this.missingTitleFields).length}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`- Missing environment/locale: ${Object.keys(this.missingEnvLocale).length}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`- Missing multiple fields: ${Object.keys(this.missingMultipleField).length}`, this.config.auditContext);
+        return result;
     }
     /**
      * The function removes any properties from the `missingRefs` object that have an empty array value.
      */
     removeEmptyVal() {
+        cli_utilities_1.log.debug('Removing empty missing reference arrays', this.config.auditContext);
+        let removedRefs = 0;
         for (let propName in this.missingRefs) {
             if (!this.missingRefs[propName].length) {
+                cli_utilities_1.log.debug(`Removing empty missing references for entry: ${propName}`, this.config.auditContext);
                 delete this.missingRefs[propName];
+                removedRefs++;
             }
         }
+        let removedSelectFields = 0;
         for (let propName in this.missingSelectFeild) {
             if (!this.missingSelectFeild[propName].length) {
+                cli_utilities_1.log.debug(`Removing empty missing select fields for entry: ${propName}`, this.config.auditContext);
                 delete this.missingSelectFeild[propName];
+                removedSelectFields++;
             }
         }
+        let removedMandatoryFields = 0;
         for (let propName in this.missingMandatoryFields) {
             if (!this.missingMandatoryFields[propName].length) {
+                cli_utilities_1.log.debug(`Removing empty missing mandatory fields for entry: ${propName}`, this.config.auditContext);
                 delete this.missingMandatoryFields[propName];
+                removedMandatoryFields++;
             }
         }
+        cli_utilities_1.log.debug(`Cleanup completed: removed ${removedRefs} empty refs, ${removedSelectFields} empty select fields, ${removedMandatoryFields} empty mandatory fields`, this.config.auditContext);
     }
     /**
      * The function `fixPrerequisiteData` fixes the prerequisite data by updating the `ctSchema` and
      * `gfSchema` properties using the `ContentType` class.
      */
     async fixPrerequisiteData() {
-        var _a;
+        var _a, _b;
+        cli_utilities_1.log.debug('Starting prerequisite data fix process', this.config.auditContext);
+        cli_utilities_1.log.debug('Fixing content type schema', this.config.auditContext);
         this.ctSchema = (await new content_types_1.default({
             fix: true,
-            log: () => { },
             config: this.config,
             moduleName: 'content-types',
             ctSchema: this.ctSchema,
             gfSchema: this.gfSchema,
         }).run(true));
+        cli_utilities_1.log.debug(`Content type schema fixed: ${this.ctSchema.length} schemas`, this.config.auditContext);
+        cli_utilities_1.log.debug('Fixing global field schema', this.config.auditContext);
         this.gfSchema = (await new global_fields_1.default({
             fix: true,
-            log: () => { },
             config: this.config,
             moduleName: 'global-fields',
             ctSchema: this.ctSchema,
             gfSchema: this.gfSchema,
         }).run(true));
+        cli_utilities_1.log.debug(`Global field schema fixed: ${this.gfSchema.length} schemas`, this.config.auditContext);
         const extensionPath = (0, path_1.resolve)(this.config.basePath, 'extensions', 'extensions.json');
         const marketplacePath = (0, path_1.resolve)(this.config.basePath, 'marketplace_apps', 'marketplace_apps.json');
+        cli_utilities_1.log.debug(`Loading extensions from: ${extensionPath}`, this.config.auditContext);
         if ((0, fs_1.existsSync)(extensionPath)) {
             try {
                 this.extensions = Object.keys(JSON.parse((0, fs_1.readFileSync)(extensionPath, 'utf8')));
+                cli_utilities_1.log.debug(`Loaded ${this.extensions.length} extensions`, this.config.auditContext);
+            }
+            catch (error) {
+                cli_utilities_1.log.debug(`Failed to load extensions: ${error}`, this.config.auditContext);
             }
-            catch (error) { }
         }
+        else {
+            cli_utilities_1.log.debug('No extensions.json found', this.config.auditContext);
+        }
+        cli_utilities_1.log.debug(`Loading marketplace apps from: ${marketplacePath}`, this.config.auditContext);
         if ((0, fs_1.existsSync)(marketplacePath)) {
             try {
                 const marketplaceApps = JSON.parse((0, fs_1.readFileSync)(marketplacePath, 'utf8'));
+                cli_utilities_1.log.debug(`Found ${marketplaceApps.length} marketplace apps`, this.config.auditContext);
                 for (const app of marketplaceApps) {
                     const metaData = (0, map_1.default)((0, map_1.default)((_a = app === null || app === void 0 ? void 0 : app.ui_location) === null || _a === void 0 ? void 0 : _a.locations, 'meta').flat(), 'extension_uid').filter((val) => val);
                     this.extensions.push(...metaData);
+                    cli_utilities_1.log.debug(`Added ${metaData.length} extension UIDs from app: ${((_b = app.manifest) === null || _b === void 0 ? void 0 : _b.name) || app.uid}`, this.config.auditContext);
                 }
             }
-            catch (error) { }
+            catch (error) {
+                cli_utilities_1.log.debug(`Failed to load marketplace apps: ${error}`, this.config.auditContext);
+            }
         }
+        else {
+            cli_utilities_1.log.debug('No marketplace_apps.json found', this.config.auditContext);
+        }
+        cli_utilities_1.log.debug(`Total extensions loaded: ${this.extensions.length}`, this.config.auditContext);
+        cli_utilities_1.log.debug('Prerequisite data fix process completed', this.config.auditContext);
     }
     /**
      * The function checks if it can write the fix content to a file and if so, it writes the content as
@@ -251,15 +332,31 @@ class Entries {
      */
     async writeFixContent(filePath, schema) {
         var _a;
-        let canWrite = true;
+        cli_utilities_1.log.debug(`Starting writeFixContent process for entries`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Target file path: ${filePath}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Entries to write: ${Object.keys(schema).length}`, this.config.auditContext);
         if (this.fix) {
-            if (!this.config.flags['copy-dir'] && !((_a = this.config.flags['external-config']) === null || _a === void 0 ? void 0 : _a.skipConfirm)) {
-                canWrite = this.config.flags.yes || (await cli_utilities_1.cliux.confirm(messages_1.commonMsg.FIX_CONFIRMATION));
+            cli_utilities_1.log.debug('Fix mode enabled, checking write permissions', this.config.auditContext);
+            const skipConfirm = this.config.flags['copy-dir'] || ((_a = this.config.flags['external-config']) === null || _a === void 0 ? void 0 : _a.skipConfirm);
+            if (skipConfirm) {
+                cli_utilities_1.log.debug('Skipping confirmation due to copy-dir or external-config flags', this.config.auditContext);
+            }
+            else {
+                cli_utilities_1.log.debug('Asking user for confirmation to write fix content', this.config.auditContext);
             }
+            const canWrite = skipConfirm || this.config.flags.yes || (await cli_utilities_1.cliux.confirm(messages_1.commonMsg.FIX_CONFIRMATION));
             if (canWrite) {
+                cli_utilities_1.log.debug(`Writing fixed entries to: ${filePath}`, this.config.auditContext);
                 (0, fs_1.writeFileSync)(filePath, JSON.stringify(schema));
+                cli_utilities_1.log.debug(`Successfully wrote ${Object.keys(schema).length} entries to file`, this.config.auditContext);
+            }
+            else {
+                cli_utilities_1.log.debug('User declined to write fix content', this.config.auditContext);
             }
         }
+        else {
+            cli_utilities_1.log.debug('Skipping writeFixContent - not in fix mode', this.config.auditContext);
+        }
     }
     /**
      * The function `lookForReference` iterates over a given schema and validates different field types
@@ -275,12 +372,18 @@ class Entries {
      */
     lookForReference(tree, field, entry) {
         var _a;
+        cli_utilities_1.log.debug(`Looking for references in field: ${field.uid || field.title || 'unknown'}`, this.config.auditContext);
+        const schemaFields = (_a = field === null || field === void 0 ? void 0 : field.schema) !== null && _a !== void 0 ? _a : [];
+        cli_utilities_1.log.debug(`Processing ${schemaFields.length} fields in schema`, this.config.auditContext);
         if (this.fix) {
+            cli_utilities_1.log.debug('Running fix on schema', this.config.auditContext);
             entry = this.runFixOnSchema(tree, field.schema, entry);
         }
-        for (const child of (_a = field === null || field === void 0 ? void 0 : field.schema) !== null && _a !== void 0 ? _a : []) {
-            const { uid, multiple, data_type } = child;
+        for (const child of schemaFields) {
+            const { uid, multiple, data_type, display_name } = child;
+            cli_utilities_1.log.debug(`Processing field: ${display_name} (${uid}) - ${data_type}`, this.config.auditContext);
             if (multiple && entry[uid] && !Array.isArray(entry[uid])) {
+                cli_utilities_1.log.debug(`Field ${display_name} should be array but is not`, this.config.auditContext);
                 if (!this.missingMultipleField[this.currentUid]) {
                     this.missingMultipleField[this.currentUid] = [];
                 }
@@ -297,41 +400,67 @@ class Entries {
                         .join(' ➜ '),
                 });
             }
+            cli_utilities_1.log.debug(`Validating mandatory fields for: ${display_name}`, this.config.auditContext);
             this.missingMandatoryFields[this.currentUid].push(...this.validateMandatoryFields([...tree, { uid: field.uid, name: child.display_name, field: uid }], child, entry));
             if (!(entry === null || entry === void 0 ? void 0 : entry[uid]) && !child.hasOwnProperty('display_type')) {
+                cli_utilities_1.log.debug(`Skipping field ${display_name} - no entry value and no display_type`, this.config.auditContext);
                 continue;
             }
+            cli_utilities_1.log.debug(`Validating field type: ${data_type} for ${display_name}`, this.config.auditContext);
             switch (child.data_type) {
                 case 'reference':
-                    this.missingRefs[this.currentUid].push(...this.validateReferenceField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]));
+                    cli_utilities_1.log.debug(`Validating reference field: ${display_name}`, this.config.auditContext);
+                    const refResults = this.validateReferenceField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
+                    this.missingRefs[this.currentUid].push(...refResults);
+                    cli_utilities_1.log.debug(`Found ${refResults.length} missing references in field: ${display_name}`, this.config.auditContext);
                     break;
                 case 'global_field':
-                    this.validateGlobalField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
+                    cli_utilities_1.log.debug(`Validating global field: ${display_name}`, this.config.auditContext);
+                    if (child.multiple && Array.isArray(entry[uid])) {
+                        cli_utilities_1.log.debug(`Processing ${entry[uid].length} multiple global field entries`, this.config.auditContext);
+                        entry[uid].forEach((globalFieldEntry, index) => {
+                            cli_utilities_1.log.debug(`Processing global field entry ${index}`, this.config.auditContext);
+                            this.validateGlobalField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, globalFieldEntry);
+                        });
+                    }
+                    else {
+                        cli_utilities_1.log.debug(`Processing single global field entry`, this.config.auditContext);
+                        this.validateGlobalField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
+                    }
                     break;
                 case 'json':
                     if ('extension' in child.field_metadata && child.field_metadata.extension) {
-                        this.missingRefs[this.currentUid].push(...this.validateExtensionAndAppField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry));
-                        // NOTE Custom field type
+                        cli_utilities_1.log.debug(`Validating extension field: ${display_name}`, this.config.auditContext);
+                        const extResults = this.validateExtensionAndAppField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry);
+                        this.missingRefs[this.currentUid].push(...extResults);
+                        cli_utilities_1.log.debug(`Found ${extResults.length} missing extension references in field: ${display_name}`, this.config.auditContext);
                     }
                     else if ('allow_json_rte' in child.field_metadata && child.field_metadata.allow_json_rte) {
                         // NOTE JSON RTE field type
+                        cli_utilities_1.log.debug(`Validating JSON RTE field: ${display_name}`, this.config.auditContext);
                         this.validateJsonRTEFields([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     }
                     break;
                 case 'blocks':
+                    cli_utilities_1.log.debug(`Validating modular blocks field: ${display_name}`, this.config.auditContext);
                     this.validateModularBlocksField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     break;
                 case 'group':
+                    cli_utilities_1.log.debug(`Validating group field: ${display_name}`, this.config.auditContext);
                     this.validateGroupField([...tree, { uid: field.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     break;
                 case 'text':
                 case 'number':
                     if (child.hasOwnProperty('display_type')) {
-                        this.missingSelectFeild[this.currentUid].push(...this.validateSelectField([...tree, { uid: field.uid, name: child.display_name, field: uid }], child, entry[uid]));
+                        cli_utilities_1.log.debug(`Validating select field: ${display_name}`, this.config.auditContext);
+                        const selectResults = this.validateSelectField([...tree, { uid: field.uid, name: child.display_name, field: uid }], child, entry[uid]);
+                        this.missingSelectFeild[this.currentUid].push(...selectResults);
+                        cli_utilities_1.log.debug(`Found ${selectResults.length} missing select field values in field: ${display_name}`, this.config.auditContext);
                     }
                     break;
             }
         }
+        cli_utilities_1.log.debug(`Field reference validation completed: ${field.uid || field.title || 'unknown'}`, this.config.auditContext);
     }
     /**
      * The function `validateReferenceField` validates the reference values of a given field in a tree
@@ -347,12 +476,16 @@ class Entries {
      * `tree`, `fieldStructure`, and `field`.
      */
     validateReferenceField(tree, fieldStructure, field) {
+        cli_utilities_1.log.debug(`Validating reference field: ${fieldStructure.display_name}`, this.config.auditContext);
         if (typeof field === 'string') {
+            cli_utilities_1.log.debug(`Converting string reference to JSON: ${field}`, this.config.auditContext);
             let stringReference = field;
             stringReference = stringReference.replace(/'/g, '"');
             field = JSON.parse(stringReference);
         }
-        return this.validateReferenceValues(tree, fieldStructure, field);
+        const result = this.validateReferenceValues(tree, fieldStructure, field);
+        cli_utilities_1.log.debug(`Reference field validation completed: ${(result === null || result === void 0 ? void 0 : result.length) || 0} missing references found`, this.config.auditContext);
+        return result;
     }
     /**
      * The function `validateExtensionAndAppField` checks if a given field has a valid extension
@@ -368,17 +501,29 @@ class Entries {
      * references, an empty array is returned.
      */
     validateExtensionAndAppField(tree, fieldStructure, field) {
-        if (this.fix)
+        cli_utilities_1.log.debug(`Validating extension/app field: ${fieldStructure.display_name}`, this.config.auditContext);
+        if (this.fix) {
+            cli_utilities_1.log.debug('Fix mode enabled, skipping extension/app validation', this.config.auditContext);
             return [];
+        }
         const missingRefs = [];
         let { uid, display_name, data_type } = fieldStructure || {};
+        cli_utilities_1.log.debug(`Checking extension/app field: ${uid}`, this.config.auditContext);
         if (field[uid]) {
             let { metadata: { extension_uid } = { extension_uid: '' } } = field[uid] || {};
+            cli_utilities_1.log.debug(`Found extension UID: ${extension_uid}`, this.config.auditContext);
             if (extension_uid && !this.extensions.includes(extension_uid)) {
+                cli_utilities_1.log.debug(`Missing extension: ${extension_uid}`, this.config.auditContext);
                 missingRefs.push({ uid, extension_uid, type: 'Extension or Apps' });
             }
+            else {
+                cli_utilities_1.log.debug(`Extension ${extension_uid} is valid`, this.config.auditContext);
+            }
+        }
+        else {
+            cli_utilities_1.log.debug(`No extension/app data found for field: ${uid}`, this.config.auditContext);
         }
-        return missingRefs.length
+        const result = missingRefs.length
             ? [
                 {
                     tree,
@@ -394,6 +539,8 @@ class Entries {
                 },
             ]
             : [];
+        cli_utilities_1.log.debug(`Extension/app field validation completed: ${result.length} missing references found`, this.config.auditContext);
+        return result;
     }
     /**
      * The function "validateGlobalField" is an asynchronous function that takes in a tree,
@@ -408,8 +555,11 @@ class Entries {
      * `EntryGlobalFieldDataType`. It represents a single global field entry.
      */
     validateGlobalField(tree, fieldStructure, field) {
+        cli_utilities_1.log.debug(`Validating global field: ${fieldStructure.display_name}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Global field UID: ${fieldStructure.uid}`, this.config.auditContext);
         // NOTE Any GlobalField related logic can be added here
         this.lookForReference(tree, fieldStructure, field);
+        cli_utilities_1.log.debug(`Global field validation completed for: ${fieldStructure.display_name}`, this.config.auditContext);
     }
     /**
      * The function `validateJsonRTEFields` is used to validate the JSON RTE fields by checking if the
@@ -424,18 +574,25 @@ class Entries {
      * such as `uid`, `attrs`, and `children`.
      */
     validateJsonRTEFields(tree, fieldStructure, field) {
-        var _a;
+        var _a, _b;
+        cli_utilities_1.log.debug(`Validating JSON RTE field: ${fieldStructure.display_name}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`JSON RTE field UID: ${fieldStructure.uid}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Found ${((_a = field === null || field === void 0 ? void 0 : field.children) === null || _a === void 0 ? void 0 : _a.length) || 0} children in JSON RTE field`, this.config.auditContext);
         // NOTE Other possible reference logic will be added related to JSON RTE (Ex missing assets, extensions etc.,)
-        for (const index in (_a = field === null || field === void 0 ? void 0 : field.children) !== null && _a !== void 0 ? _a : []) {
+        for (const index in (_b = field === null || field === void 0 ? void 0 : field.children) !== null && _b !== void 0 ? _b : []) {
             const child = field.children[index];
             const { children } = child;
+            cli_utilities_1.log.debug(`Processing JSON RTE child ${index}`, this.config.auditContext);
             if (!this.fix) {
+                cli_utilities_1.log.debug(`Checking JSON RTE references for child ${index}`, this.config.auditContext);
                 this.jsonRefCheck(tree, fieldStructure, child);
             }
             if (!(0, isEmpty_1.default)(children)) {
+                cli_utilities_1.log.debug(`Recursively validating JSON RTE children for child ${index}`, this.config.auditContext);
                 this.validateJsonRTEFields(tree, fieldStructure, field.children[index]);
             }
         }
+        cli_utilities_1.log.debug(`JSON RTE field validation completed for: ${fieldStructure.display_name}`, this.config.auditContext);
     }
     /**
      * The function validates the modular blocks field by traversing each module and looking for
@@ -451,19 +608,28 @@ class Entries {
      * `EntryModularBlocksDataType`.
      */
     validateModularBlocksField(tree, fieldStructure, field) {
+        cli_utilities_1.log.debug(`Validating modular blocks field: ${fieldStructure.display_name}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Modular blocks field UID: ${fieldStructure.uid}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Found ${field.length} modular blocks`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Available blocks: ${fieldStructure.blocks.map(b => b.title).join(', ')}`);
         if (!this.fix) {
+            cli_utilities_1.log.debug('Checking modular block references (non-fix mode)');
             for (const index in field) {
+                cli_utilities_1.log.debug(`Checking references for modular block ${index}`);
                 this.modularBlockRefCheck(tree, fieldStructure.blocks, field[index], +index);
             }
         }
         for (const block of fieldStructure.blocks) {
             const { uid, title } = block;
+            cli_utilities_1.log.debug(`Processing block: ${title} (${uid})`);
             for (const eBlock of field) {
                 if (eBlock[uid]) {
+                    cli_utilities_1.log.debug(`Found entry block data for: ${title}`);
                     this.lookForReference([...tree, { uid, name: title }], block, eBlock[uid]);
                 }
             }
         }
+        cli_utilities_1.log.debug(`Modular blocks field validation completed for: ${fieldStructure.display_name}`);
     }
     /**
      * The function validates a group field by looking for a reference in a tree structure.
@@ -475,15 +641,22 @@ class Entries {
      * `EntryGroupFieldDataType` and represents a single group field entry.
      */
     validateGroupField(tree, fieldStructure, field) {
+        cli_utilities_1.log.debug(`Validating group field: ${fieldStructure.display_name}`);
+        cli_utilities_1.log.debug(`Group field UID: ${fieldStructure.uid}`);
+        cli_utilities_1.log.debug(`Group field type: ${Array.isArray(field) ? 'array' : 'single'}`);
         // NOTE Any Group Field related logic can be added here (Ex data serialization or picking any metadata for report etc.,)
         if (Array.isArray(field)) {
-            field.forEach((eGroup) => {
+            cli_utilities_1.log.debug(`Processing ${field.length} group field entries`);
+            field.forEach((eGroup, index) => {
+                cli_utilities_1.log.debug(`Processing group field entry ${index}`);
                 this.lookForReference([...tree, { uid: fieldStructure.uid, display_name: fieldStructure.display_name }], fieldStructure, eGroup);
             });
         }
         else {
+            cli_utilities_1.log.debug('Processing single group field entry');
             this.lookForReference(tree, fieldStructure, field);
         }
+        cli_utilities_1.log.debug(`Group field validation completed for: ${fieldStructure.display_name}`);
     }
     /**
      * The function `validateReferenceValues` checks if the references in a given field exist in the
@@ -501,16 +674,25 @@ class Entries {
      * objects.
      */
     validateReferenceValues(tree, fieldStructure, field) {
-        if (this.fix)
+        cli_utilities_1.log.debug(`Validating reference values for field: ${fieldStructure.display_name}`);
+        if (this.fix) {
+            cli_utilities_1.log.debug('Fix mode enabled, skipping reference validation');
             return [];
+        }
         const missingRefs = [];
         const { uid: data_type, display_name, reference_to } = fieldStructure;
+        cli_utilities_1.log.debug(`Reference field UID: ${data_type}`);
+        cli_utilities_1.log.debug(`Reference to: ${(reference_to === null || reference_to === void 0 ? void 0 : reference_to.join(', ')) || 'none'}`);
+        cli_utilities_1.log.debug(`Found ${(field === null || field === void 0 ? void 0 : field.length) || 0} references to validate`);
         for (const index in field !== null && field !== void 0 ? field : []) {
             const reference = field[index];
             const { uid } = reference;
+            cli_utilities_1.log.debug(`Processing reference ${index}: ${uid || reference}`);
             if (!uid && reference.startsWith('blt')) {
+                cli_utilities_1.log.debug(`Checking reference: ${reference}`);
                 const refExist = (0, find_1.default)(this.entryMetaData, { uid: reference });
                 if (!refExist) {
+                    cli_utilities_1.log.debug(`Missing reference: ${reference}`);
                     if (Array.isArray(reference_to) && reference_to.length === 1) {
                         missingRefs.push({ uid: reference, _content_type_uid: reference_to[0] });
                     }
@@ -518,17 +700,25 @@ class Entries {
                         missingRefs.push(reference);
                     }
                 }
+                else {
+                    cli_utilities_1.log.debug(`Reference ${reference} is valid`);
+                }
             }
             // NOTE Can skip specific references keys (Ex, system defined keys can be skipped)
             // if (this.config.skipRefs.includes(reference)) continue;
             else {
+                cli_utilities_1.log.debug(`Checking standard reference: ${uid}`);
                 const refExist = (0, find_1.default)(this.entryMetaData, { uid });
                 if (!refExist) {
+                    cli_utilities_1.log.debug(`Missing reference: ${uid}`);
                     missingRefs.push(reference);
                 }
+                else {
+                    cli_utilities_1.log.debug(`Reference ${uid} is valid`);
+                }
             }
         }
-        return missingRefs.length
+        const result = missingRefs.length
             ? [
                 {
                     tree,
@@ -544,17 +734,24 @@ class Entries {
                 },
             ]
             : [];
+        cli_utilities_1.log.debug(`Reference values validation completed: ${result.length} missing references found`);
+        return result;
     }
     removeMissingKeysOnEntry(schema, entry) {
+        cli_utilities_1.log.debug(`Removing missing keys from entry: ${this.currentUid}`);
         // NOTE remove invalid entry keys
         const ctFields = (0, map_1.default)(schema, 'uid');
         const entryFields = Object.keys(entry !== null && entry !== void 0 ? entry : {});
+        cli_utilities_1.log.debug(`Content type fields: ${ctFields.length}, Entry fields: ${entryFields.length}`);
+        cli_utilities_1.log.debug(`System keys: ${this.config.entries.systemKeys.join(', ')}`);
         entryFields.forEach((eKey) => {
             // NOTE Key should not be system key and not exist in schema means it's invalid entry key
             if (!this.config.entries.systemKeys.includes(eKey) && !ctFields.includes(eKey)) {
+                cli_utilities_1.log.debug(`Removing invalid field: ${eKey}`);
                 delete entry[eKey];
             }
         });
+        cli_utilities_1.log.debug(`Missing keys removal completed for entry: ${this.currentUid}`);
     }
     /**
      * The function `runFixOnSchema` takes in a tree, schema, and entry, and applies fixes to the entry
@@ -571,15 +768,20 @@ class Entries {
      * `schema`.
      */
     runFixOnSchema(tree, schema, entry) {
+        cli_utilities_1.log.debug(`Running fix on schema for entry: ${this.currentUid}`);
+        cli_utilities_1.log.debug(`Schema fields: ${schema.length}, Entry fields: ${Object.keys(entry).length}`);
         // NOTE Global field Fix
         schema.forEach((field) => {
             var _a;
             var _b, _c;
             const { uid, data_type, multiple } = field;
+            cli_utilities_1.log.debug(`Processing field: ${uid} (${data_type})`);
             if (!Object(entry).hasOwnProperty(uid)) {
+                cli_utilities_1.log.debug(`Field ${uid} not found in entry, skipping`);
                 return;
             }
             if (multiple && entry[uid] && !Array.isArray(entry[uid])) {
+                cli_utilities_1.log.debug(`Fixing multiple field: ${uid} - converting to array`);
                 (_a = (_b = this.missingMultipleField)[_c = this.currentUid]) !== null && _a !== void 0 ? _a : (_b[_c] = []);
                 this.missingMultipleField[this.currentUid].push({
                     uid: this.currentUid,
@@ -598,41 +800,61 @@ class Entries {
             }
             switch (data_type) {
                 case 'global_field':
-                    entry[uid] = this.fixGlobalFieldReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
+                    cli_utilities_1.log.debug(`Fixing global field: ${uid}`);
+                    if (field.multiple && Array.isArray(entry[uid])) {
+                        cli_utilities_1.log.debug(`Fixing ${entry[uid].length} multiple global field entries`, this.config.auditContext);
+                        entry[uid] = entry[uid].map((globalFieldEntry, index) => {
+                            cli_utilities_1.log.debug(`Fixing global field entry ${index}`, this.config.auditContext);
+                            return this.fixGlobalFieldReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, globalFieldEntry);
+                        });
+                    }
+                    else {
+                        cli_utilities_1.log.debug(`Fixing single global field entry`, this.config.auditContext);
+                        entry[uid] = this.fixGlobalFieldReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
+                    }
                     break;
                 case 'json':
                 case 'reference':
+                    cli_utilities_1.log.debug(`Fixing ${data_type} field: ${uid}`);
                     if (data_type === 'json') {
                         if ('extension' in field.field_metadata && field.field_metadata.extension) {
                             // NOTE Custom field type
+                            cli_utilities_1.log.debug(`Fixing extension/app field: ${uid}`);
                             this.fixMissingExtensionOrApp([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry);
                             break;
                         }
                         else if ('allow_json_rte' in field.field_metadata && field.field_metadata.allow_json_rte) {
+                            cli_utilities_1.log.debug(`Fixing JSON RTE field: ${uid}`);
                             this.fixJsonRteMissingReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
                             break;
                         }
                     }
                     // NOTE Reference field
+                    cli_utilities_1.log.debug(`Fixing reference field: ${uid}`);
                     entry[uid] = this.fixMissingReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
                     if (!entry[uid]) {
+                        cli_utilities_1.log.debug(`Deleting empty reference field: ${uid}`);
                         delete entry[uid];
                     }
                     break;
                 case 'blocks':
+                    cli_utilities_1.log.debug(`Fixing modular blocks field: ${uid}`);
                     entry[uid] = this.fixModularBlocksReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field.blocks, entry[uid]);
                     break;
                 case 'group':
+                    cli_utilities_1.log.debug(`Fixing group field: ${uid}`);
                     entry[uid] = this.fixGroupField([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
                     break;
                 case 'text':
                 case 'number':
                     if (field.hasOwnProperty('display_type')) {
+                        cli_utilities_1.log.debug(`Fixing select field: ${uid}`);
                         entry[uid] = this.fixSelectField([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
                     }
                     break;
             }
         });
+        cli_utilities_1.log.debug(`Schema fix completed for entry: ${this.currentUid}`);
         return entry;
     }
     /**
@@ -648,11 +870,16 @@ class Entries {
         return str === null || str === void 0 ? void 0 : str.replace(/[\p{Emoji}\p{Emoji_Presentation}\p{Emoji_Modifier}\p{Emoji_Modifier_Base}\p{Emoji_Component}]+/gu, '');
     }
     validateSelectField(tree, fieldStructure, field) {
+        cli_utilities_1.log.debug(`Validating select field: ${fieldStructure.display_name}`);
+        cli_utilities_1.log.debug(`Select field UID: ${fieldStructure.uid}`);
+        cli_utilities_1.log.debug(`Field value: ${JSON.stringify(field)}`);
+        cli_utilities_1.log.debug(`Multiple: ${fieldStructure.multiple}, Display type: ${fieldStructure.display_type}`);
         const { display_name, enum: selectOptions, multiple, min_instance, display_type, data_type } = fieldStructure;
         if (field === null ||
             field === '' ||
             (Array.isArray(field) && field.length === 0) ||
             (!field && data_type !== 'number')) {
+            cli_utilities_1.log.debug(`Select field is empty or null: ${display_name}`);
             let missingCTSelectFieldValues = 'Not Selected';
             return [
                 {
@@ -672,18 +899,32 @@ class Entries {
         }
         let missingCTSelectFieldValues;
         if (multiple) {
+            cli_utilities_1.log.debug(`Validating multiple select field: ${display_name}`);
             if (Array.isArray(field)) {
+                cli_utilities_1.log.debug(`Field is array with ${field.length} values`);
                 let obj = this.findNotPresentSelectField(field, selectOptions);
                 let { notPresent } = obj;
                 if (notPresent.length) {
+                    cli_utilities_1.log.debug(`Found ${notPresent.length} missing select values: ${notPresent.join(', ')}`);
                     missingCTSelectFieldValues = notPresent;
                 }
+                else {
+                    cli_utilities_1.log.debug(`All select values are valid`);
+                }
             }
         }
-        else if (!selectOptions.choices.some((choice) => choice.value === field)) {
-            missingCTSelectFieldValues = field;
+        else {
+            cli_utilities_1.log.debug(`Validating single select field: ${display_name}`);
+            if (!selectOptions.choices.some((choice) => choice.value === field)) {
+                cli_utilities_1.log.debug(`Invalid select value: ${field}`);
+                missingCTSelectFieldValues = field;
+            }
+            else {
+                cli_utilities_1.log.debug(`Select value is valid: ${field}`);
+            }
         }
         if (display_type && missingCTSelectFieldValues) {
+            cli_utilities_1.log.debug(`Select field validation found issues: ${JSON.stringify(missingCTSelectFieldValues)}`);
             return [
                 {
                     uid: this.currentUid,
@@ -701,6 +942,7 @@ class Entries {
             ];
         }
         else {
+            cli_utilities_1.log.debug(`Select field validation completed successfully: ${display_name}`);
             return [];
         }
     }
@@ -715,56 +957,74 @@ class Entries {
      * @returns
      */
     fixSelectField(tree, field, entry) {
+        cli_utilities_1.log.debug(`Fixing select field: ${field.display_name}`);
+        cli_utilities_1.log.debug(`Select field UID: ${field.uid}`);
+        cli_utilities_1.log.debug(`Current entry value: ${JSON.stringify(entry)}`);
         if (!this.config.fixSelectField) {
+            cli_utilities_1.log.debug('Select field fixing is disabled in config');
             return entry;
         }
         const { enum: selectOptions, multiple, min_instance, display_type, display_name, uid } = field;
+        cli_utilities_1.log.debug(`Select options: ${selectOptions.choices.length} choices, Multiple: ${multiple}, Min instance: ${min_instance}`);
         let missingCTSelectFieldValues;
         let isMissingValuePresent = false;
         let selectedValue = '';
         if (multiple) {
+            cli_utilities_1.log.debug('Processing multiple select field', this.config.auditContext);
             let obj = this.findNotPresentSelectField(entry, selectOptions);
             let { notPresent, filteredFeild } = obj;
+            cli_utilities_1.log.debug(`Found ${notPresent.length} invalid values, filtered to ${filteredFeild.length} values`, this.config.auditContext);
             entry = filteredFeild;
             missingCTSelectFieldValues = notPresent;
             if (missingCTSelectFieldValues.length) {
                 isMissingValuePresent = true;
+                cli_utilities_1.log.debug(`Missing values found: ${missingCTSelectFieldValues.join(', ')}`, this.config.auditContext);
             }
             if (min_instance && Array.isArray(entry)) {
                 const missingInstances = min_instance - entry.length;
+                cli_utilities_1.log.debug(`Checking min instance requirement: ${min_instance}, current: ${entry.length}, missing: ${missingInstances}`, this.config.auditContext);
                 if (missingInstances > 0) {
                     isMissingValuePresent = true;
                     const newValues = selectOptions.choices
                         .filter((choice) => !entry.includes(choice.value))
                         .slice(0, missingInstances)
                         .map((choice) => choice.value);
+                    cli_utilities_1.log.debug(`Adding ${newValues.length} values to meet min instance requirement: ${newValues.join(', ')}`, this.config.auditContext);
                     entry.push(...newValues);
                     selectedValue = newValues;
-                    this.log((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: newValues.join(' '), uid }), 'error');
+                    cli_utilities_1.log.error((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: newValues.join(' '), uid }), this.config.auditContext);
                 }
             }
             else {
                 if (entry.length === 0) {
                     isMissingValuePresent = true;
                     const defaultValue = selectOptions.choices.length > 0 ? selectOptions.choices[0].value : null;
+                    cli_utilities_1.log.debug(`Empty multiple select field, adding default value: ${defaultValue}`, this.config.auditContext);
                     entry.push(defaultValue);
                     selectedValue = defaultValue;
-                    this.log((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: defaultValue, uid }), 'error');
+                    cli_utilities_1.log.error((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: defaultValue, uid }), this.config.auditContext);
                 }
             }
         }
         else {
+            cli_utilities_1.log.debug('Processing single select field', this.config.auditContext);
             const isPresent = selectOptions.choices.some((choice) => choice.value === entry);
             if (!isPresent) {
+                cli_utilities_1.log.debug(`Invalid single select value: ${entry}`, this.config.auditContext);
                 missingCTSelectFieldValues = entry;
                 isMissingValuePresent = true;
                 let defaultValue = selectOptions.choices.length > 0 ? selectOptions.choices[0].value : null;
+                cli_utilities_1.log.debug(`Replacing with default value: ${defaultValue}`, this.config.auditContext);
                 entry = defaultValue;
                 selectedValue = defaultValue;
-                this.log((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: defaultValue, uid }), 'error');
+                cli_utilities_1.log.error((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: defaultValue, uid }), this.config.auditContext);
+            }
+            else {
+                cli_utilities_1.log.debug(`Single select value is valid: ${entry}`, this.config.auditContext);
             }
         }
         if (display_type && isMissingValuePresent) {
+            cli_utilities_1.log.debug(`Recording select field fix for entry: ${this.currentUid}`, this.config.auditContext);
             this.missingSelectFeild[this.currentUid].push({
                 uid: this.currentUid,
                 name: this.currentTitle,
@@ -781,15 +1041,19 @@ class Entries {
                 fixStatus: 'Fixed',
             });
         }
+        cli_utilities_1.log.debug(`Select field fix completed for: ${field.display_name}`);
         return entry;
     }
     validateMandatoryFields(tree, fieldStructure, entry) {
+        cli_utilities_1.log.debug(`Validating mandatory field: ${fieldStructure.display_name}`);
+        cli_utilities_1.log.debug(`Field UID: ${fieldStructure.uid}, Mandatory: ${fieldStructure.mandatory}`);
         const { display_name, multiple, data_type, mandatory, field_metadata, uid } = fieldStructure;
         const isJsonRteEmpty = () => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
             const jsonNode = multiple
                 ? (_f = (_e = (_d = (_c = (_b = (_a = entry[uid]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.children) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.children) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.text
                 : (_l = (_k = (_j = (_h = (_g = entry[uid]) === null || _g === void 0 ? void 0 : _g.children) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.children) === null || _k === void 0 ? void 0 : _k[0]) === null || _l === void 0 ? void 0 : _l.text;
+            cli_utilities_1.log.debug(`JSON RTE empty check: ${jsonNode === ''}`);
             return jsonNode === '';
         };
         const isEntryEmpty = () => {
@@ -804,10 +1068,13 @@ class Entries {
             if (Array.isArray(entry[uid]) && data_type === 'reference') {
                 fieldValue = ((_b = entry[uid]) === null || _b === void 0 ? void 0 : _b.length) ? true : false;
             }
+            cli_utilities_1.log.debug(`Entry empty check: ${fieldValue === '' || !fieldValue}`);
             return fieldValue === '' || !fieldValue;
         };
         if (mandatory) {
+            cli_utilities_1.log.debug(`Field is mandatory, checking if empty`);
             if ((data_type === 'json' && field_metadata.allow_json_rte && isJsonRteEmpty()) || isEntryEmpty()) {
+                cli_utilities_1.log.debug(`Mandatory field is empty: ${display_name}`);
                 return [
                     {
                         uid: this.currentUid,
@@ -822,7 +1089,14 @@ class Entries {
                     },
                 ];
             }
+            else {
+                cli_utilities_1.log.debug(`Mandatory field has value: ${display_name}`);
+            }
         }
+        else {
+            cli_utilities_1.log.debug(`Field is not mandatory: ${display_name}`);
+        }
+        cli_utilities_1.log.debug(`Mandatory field validation completed: ${display_name}`);
         return [];
     }
     /**
@@ -832,21 +1106,30 @@ class Entries {
      * @returns An Array of entry containing only the values that were present in CT, An array of not present entries
      */
     findNotPresentSelectField(field, selectOptions) {
+        cli_utilities_1.log.debug(`Finding not present select field values`);
+        cli_utilities_1.log.debug(`Field values: ${JSON.stringify(field)}`);
+        cli_utilities_1.log.debug(`Available choices: ${selectOptions.choices.length}`);
         if (!field) {
+            cli_utilities_1.log.debug('Field is null/undefined, initializing as empty array');
             field = [];
         }
         let present = [];
         let notPresent = [];
         const choicesMap = new Map(selectOptions.choices.map((choice) => [choice.value, choice]));
+        cli_utilities_1.log.debug(`Created choices map with ${choicesMap.size} entries`);
         for (const value of field) {
             const choice = choicesMap.get(value);
+            cli_utilities_1.log.debug(`Checking value: ${value}`);
             if (choice) {
+                cli_utilities_1.log.debug(`Value ${value} is present in choices`);
                 present.push(choice.value);
             }
             else {
+                cli_utilities_1.log.debug(`Value ${value} is not present in choices`);
                 notPresent.push(value);
             }
         }
+        cli_utilities_1.log.debug(`Result: ${present.length} present, ${notPresent.length} not present`);
         return { filteredFeild: present, notPresent };
     }
     /**
@@ -861,7 +1144,13 @@ class Entries {
      * `field.schema`, and `entry` as arguments.
      */
     fixGlobalFieldReferences(tree, field, entry) {
-        return this.runFixOnSchema([...tree, { uid: field.uid, display_name: field.display_name }], field.schema, entry);
+        var _a;
+        cli_utilities_1.log.debug(`Fixing global field references: ${field.display_name}`);
+        cli_utilities_1.log.debug(`Global field UID: ${field.uid}`);
+        cli_utilities_1.log.debug(`Schema fields: ${((_a = field.schema) === null || _a === void 0 ? void 0 : _a.length) || 0}`);
+        const result = this.runFixOnSchema([...tree, { uid: field.uid, display_name: field.display_name }], field.schema, entry);
+        cli_utilities_1.log.debug(`Global field references fix completed: ${field.display_name}`);
+        return result;
     }
     /**
      * The function `fixModularBlocksReferences` takes in a tree, a list of blocks, and an entry, and
@@ -876,17 +1165,33 @@ class Entries {
      * @returns the updated `entry` array after performing some modifications.
      */
     fixModularBlocksReferences(tree, blocks, entry) {
-        entry = entry === null || entry === void 0 ? void 0 : entry.map((block, index) => this.modularBlockRefCheck(tree, blocks, block, index)).filter((val) => !(0, isEmpty_1.default)(val));
+        cli_utilities_1.log.debug(`Fixing modular blocks references`);
+        cli_utilities_1.log.debug(`Available blocks: ${blocks.length}, Entry blocks: ${(entry === null || entry === void 0 ? void 0 : entry.length) || 0}`);
+        entry = entry === null || entry === void 0 ? void 0 : entry.map((block, index) => {
+            cli_utilities_1.log.debug(`Checking modular block ${index}`);
+            return this.modularBlockRefCheck(tree, blocks, block, index);
+        }).filter((val) => {
+            const isEmpty = !val || Object.keys(val).length === 0;
+            cli_utilities_1.log.debug(`Block ${val ? 'kept' : 'filtered out'} (empty: ${isEmpty})`);
+            return !isEmpty;
+        });
         blocks.forEach((block) => {
+            cli_utilities_1.log.debug(`Processing block: ${block.title} (${block.uid})`);
             entry = entry === null || entry === void 0 ? void 0 : entry.map((eBlock) => {
                 if (!(0, isEmpty_1.default)(block.schema)) {
                     if (eBlock[block.uid]) {
+                        cli_utilities_1.log.debug(`Fixing schema for block: ${block.title}`);
                         eBlock[block.uid] = this.runFixOnSchema([...tree, { uid: block.uid, display_name: block.title }], block.schema, eBlock[block.uid]);
                     }
                 }
                 return eBlock;
-            }).filter((val) => !(0, isEmpty_1.default)(val));
+            }).filter((val) => {
+                const isEmpty = !val || Object.keys(val).length === 0;
+                cli_utilities_1.log.debug(`Entry block ${val ? 'kept' : 'filtered out'} (empty: ${isEmpty})`);
+                return !isEmpty;
+            });
         });
+        cli_utilities_1.log.debug(`Modular blocks references fix completed: ${(entry === null || entry === void 0 ? void 0 : entry.length) || 0} blocks remaining`);
         return entry;
     }
     /**
@@ -903,15 +1208,26 @@ class Entries {
      * @returns the `field` parameter.
      */
     fixMissingExtensionOrApp(tree, field, entry) {
+        cli_utilities_1.log.debug(`Fixing missing extension/app: ${field.display_name}`);
+        cli_utilities_1.log.debug(`Extension/app field UID: ${field.uid}`);
         const missingRefs = [];
         let { uid, display_name, data_type } = field || {};
         if (entry[uid]) {
             let { metadata: { extension_uid } = { extension_uid: '' } } = entry[uid] || {};
+            cli_utilities_1.log.debug(`Found extension UID: ${extension_uid}`);
             if (extension_uid && !this.extensions.includes(extension_uid)) {
+                cli_utilities_1.log.debug(`Missing extension: ${extension_uid}`, this.config.auditContext);
                 missingRefs.push({ uid, extension_uid, type: 'Extension or Apps' });
             }
+            else {
+                cli_utilities_1.log.debug(`Extension ${extension_uid} is valid`, this.config.auditContext);
+            }
+        }
+        else {
+            cli_utilities_1.log.debug(`No extension/app data found for field: ${uid}`, this.config.auditContext);
         }
         if (this.fix && !(0, isEmpty_1.default)(missingRefs)) {
+            cli_utilities_1.log.debug(`Recording extension/app fix for entry: ${this.currentUid}`);
             this.missingRefs[this.currentUid].push({
                 tree,
                 data_type,
@@ -922,8 +1238,10 @@ class Entries {
                 name: this.currentTitle,
                 treeStr: tree.map(({ name }) => name).join(' ➜ '),
             });
+            cli_utilities_1.log.debug(`Deleting invalid extension/app field: ${uid}`);
             delete entry[uid];
         }
+        cli_utilities_1.log.debug(`Extension/app fix completed for: ${field.display_name}`);
         return field;
     }
     /**
@@ -941,16 +1259,29 @@ class Entries {
      * Otherwise, it will return the `entry` as is.
      */
     fixGroupField(tree, field, entry) {
+        var _a;
+        cli_utilities_1.log.debug(`Fixing group field: ${field.display_name}`);
+        cli_utilities_1.log.debug(`Group field UID: ${field.uid}`);
+        cli_utilities_1.log.debug(`Schema fields: ${((_a = field.schema) === null || _a === void 0 ? void 0 : _a.length) || 0}`);
+        cli_utilities_1.log.debug(`Entry type: ${Array.isArray(entry) ? 'array' : 'single'}`);
         if (!(0, isEmpty_1.default)(field.schema)) {
+            cli_utilities_1.log.debug(`Group field has schema, applying fixes`);
             if (Array.isArray(entry)) {
-                entry = entry.map((eGroup) => {
+                cli_utilities_1.log.debug(`Processing ${entry.length} group field entries`);
+                entry = entry.map((eGroup, index) => {
+                    cli_utilities_1.log.debug(`Fixing group field entry ${index}`);
                     return this.runFixOnSchema([...tree, { uid: field.uid, display_name: field.display_name }], field.schema, eGroup);
                 });
             }
             else {
+                cli_utilities_1.log.debug(`Processing single group field entry`);
                 entry = this.runFixOnSchema([...tree, { uid: field.uid, display_name: field.display_name }], field.schema, entry);
             }
         }
+        else {
+            cli_utilities_1.log.debug(`Group field has no schema, skipping fixes`);
+        }
+        cli_utilities_1.log.debug(`Group field fix completed for: ${field.display_name}`);
         return entry;
     }
     /**
@@ -964,26 +1295,45 @@ class Entries {
      * @returns the updated `entry` object with fixed missing references in the `children` property.
      */
     fixJsonRteMissingReferences(tree, field, entry) {
+        cli_utilities_1.log.debug(`Fixing JSON RTE missing references`);
+        cli_utilities_1.log.debug(`Field UID: ${field.uid}`);
+        cli_utilities_1.log.debug(`Entry type: ${Array.isArray(entry) ? 'array' : 'single'}`);
         if (Array.isArray(entry)) {
+            cli_utilities_1.log.debug(`Processing ${entry.length} JSON RTE entries`);
             entry = entry.map((child, index) => {
+                cli_utilities_1.log.debug(`Fixing JSON RTE entry ${index}: ${(child === null || child === void 0 ? void 0 : child.type) || 'unknown type'}`);
                 return this.fixJsonRteMissingReferences([...tree, { index, type: child === null || child === void 0 ? void 0 : child.type, uid: child === null || child === void 0 ? void 0 : child.uid }], field, child);
             });
         }
         else {
             if (entry === null || entry === void 0 ? void 0 : entry.children) {
+                cli_utilities_1.log.debug(`Processing ${entry.children.length} JSON RTE children`);
                 entry.children = entry.children
-                    .map((child) => {
+                    .map((child, index) => {
+                    cli_utilities_1.log.debug(`Checking JSON RTE child ${index}: ${child.type || 'unknown type'}`);
                     const refExist = this.jsonRefCheck(tree, field, child);
-                    if (!refExist)
+                    if (!refExist) {
+                        cli_utilities_1.log.debug(`JSON RTE child ${index} has invalid reference, removing`);
                         return null;
+                    }
                     if (!(0, isEmpty_1.default)(child.children)) {
+                        cli_utilities_1.log.debug(`JSON RTE child ${index} has children, recursively fixing`);
                         child = this.fixJsonRteMissingReferences(tree, field, child);
                     }
+                    cli_utilities_1.log.debug(`JSON RTE child ${index} reference is valid`);
                     return child;
                 })
-                    .filter((val) => val);
+                    .filter((val) => {
+                    const isValid = val !== null;
+                    cli_utilities_1.log.debug(`JSON RTE child ${val ? 'kept' : 'filtered out'}`);
+                    return isValid;
+                });
+            }
+            else {
+                cli_utilities_1.log.debug(`JSON RTE entry has no children`);
             }
         }
+        cli_utilities_1.log.debug(`JSON RTE missing references fix completed`);
         return entry;
     }
     /**
@@ -998,18 +1348,28 @@ class Entries {
      * @returns the `entry` variable.
      */
     fixMissingReferences(tree, field, entry) {
+        var _a;
+        cli_utilities_1.log.debug(`Fixing missing references`);
+        cli_utilities_1.log.debug(`Field UID: ${field.uid}`);
+        cli_utilities_1.log.debug(`Reference to: ${((_a = field.reference_to) === null || _a === void 0 ? void 0 : _a.join(', ')) || 'none'}`);
+        cli_utilities_1.log.debug(`Entry type: ${typeof entry}, length: ${Array.isArray(entry) ? entry.length : 'N/A'}`);
         const missingRefs = [];
         if (typeof entry === 'string') {
+            cli_utilities_1.log.debug(`Entry is string, parsing JSON`);
             let stringReference = entry;
             stringReference = stringReference.replace(/'/g, '"');
             entry = JSON.parse(stringReference);
+            cli_utilities_1.log.debug(`Parsed entry: ${Array.isArray(entry) ? entry.length : 'N/A'} references`);
         }
-        entry = entry === null || entry === void 0 ? void 0 : entry.map((reference) => {
+        entry = entry === null || entry === void 0 ? void 0 : entry.map((reference, index) => {
             const { uid } = reference;
             const { reference_to } = field;
+            cli_utilities_1.log.debug(`Processing reference ${index}: ${uid || reference}`);
             if (!uid && reference.startsWith('blt')) {
+                cli_utilities_1.log.debug(`Checking blt reference: ${reference}`);
                 const refExist = (0, find_1.default)(this.entryMetaData, { uid: reference });
                 if (!refExist) {
+                    cli_utilities_1.log.debug(`Missing blt reference: ${reference}`);
                     if (Array.isArray(reference_to) && reference_to.length === 1) {
                         missingRefs.push({ uid: reference, _content_type_uid: reference_to[0] });
                     }
@@ -1018,21 +1378,30 @@ class Entries {
                     }
                 }
                 else {
+                    cli_utilities_1.log.debug(`Blt reference ${reference} is valid`);
                     return { uid: reference, _content_type_uid: refExist.ctUid };
                 }
             }
             else {
+                cli_utilities_1.log.debug(`Checking standard reference: ${uid}`);
                 const refExist = (0, find_1.default)(this.entryMetaData, { uid });
                 if (!refExist) {
+                    cli_utilities_1.log.debug(`Missing reference: ${uid}`);
                     missingRefs.push(reference);
                     return null;
                 }
                 else {
+                    cli_utilities_1.log.debug(`Reference ${uid} is valid`);
                     return reference;
                 }
             }
-        }).filter((val) => val);
+        }).filter((val) => {
+            const isValid = val !== null;
+            cli_utilities_1.log.debug(`Reference ${val ? 'kept' : 'filtered out'}`);
+            return isValid;
+        });
         if (!(0, isEmpty_1.default)(missingRefs)) {
+            cli_utilities_1.log.debug(`Recording ${missingRefs.length} missing references for entry: ${this.currentUid}`);
             this.missingRefs[this.currentUid].push({
                 tree,
                 fixStatus: 'Fixed',
@@ -1047,6 +1416,10 @@ class Entries {
                 missingRefs,
             });
         }
+        else {
+            cli_utilities_1.log.debug(`No missing references found`);
+        }
+        cli_utilities_1.log.debug(`Missing references fix completed: ${(entry === null || entry === void 0 ? void 0 : entry.length) || 0} references remaining`);
         return entry;
     }
     /**
@@ -1064,12 +1437,18 @@ class Entries {
      * @returns the `entryBlock` object.
      */
     modularBlockRefCheck(tree, blocks, entryBlock, index) {
+        cli_utilities_1.log.debug(`Checking modular block references for block ${index}`);
+        cli_utilities_1.log.debug(`Available block UIDs: ${blocks.map(b => b.uid).join(', ')}`);
+        cli_utilities_1.log.debug(`Entry block keys: ${Object.keys(entryBlock).join(', ')}`);
         const validBlockUid = blocks.map((block) => block.uid);
         const invalidKeys = Object.keys(entryBlock).filter((key) => !validBlockUid.includes(key));
+        cli_utilities_1.log.debug(`Found ${invalidKeys.length} invalid keys: ${invalidKeys.join(', ')}`);
         invalidKeys.forEach((key) => {
             if (this.fix) {
+                cli_utilities_1.log.debug(`Deleting invalid key: ${key}`);
                 delete entryBlock[key];
             }
+            cli_utilities_1.log.debug(`Recording invalid modular block key: ${key}`);
             this.missingRefs[this.currentUid].push({
                 uid: this.currentUid,
                 name: this.currentTitle,
@@ -1084,6 +1463,7 @@ class Entries {
                 missingRefs: [key],
             });
         });
+        cli_utilities_1.log.debug(`Modular block reference check completed for block ${index}`);
         return entryBlock;
     }
     /**
@@ -1098,11 +1478,16 @@ class Entries {
      * @returns The function `jsonRefCheck` returns either `null` or `true`.
      */
     jsonRefCheck(tree, schema, child) {
+        cli_utilities_1.log.debug(`Checking JSON reference for child: ${child.type || 'unknown type'}`);
+        cli_utilities_1.log.debug(`Child UID: ${child.uid}`);
         const { uid: childrenUid } = child;
         const { 'entry-uid': entryUid, 'content-type-uid': contentTypeUid } = child.attrs || {};
+        cli_utilities_1.log.debug(`Entry UID: ${entryUid}, Content type UID: ${contentTypeUid}`);
         if (entryUid) {
+            cli_utilities_1.log.debug(`Checking entry reference: ${entryUid}`);
             const refExist = (0, find_1.default)(this.entryMetaData, { uid: entryUid });
             if (!refExist) {
+                cli_utilities_1.log.debug(`Missing entry reference: ${entryUid}`);
                 tree.push({ field: 'children' }, { field: childrenUid, uid: schema.uid });
                 this.missingRefs[this.currentUid].push({
                     tree,
@@ -1117,9 +1502,17 @@ class Entries {
                         .join(' ➜ '),
                     missingRefs: [{ uid: entryUid, 'content-type-uid': contentTypeUid }],
                 });
+                cli_utilities_1.log.debug(`JSON reference check failed for entry: ${entryUid}`);
                 return null;
             }
+            else {
+                cli_utilities_1.log.debug(`Entry reference ${entryUid} is valid`);
+            }
         }
+        else {
+            cli_utilities_1.log.debug(`No entry UID found in JSON child`);
+        }
+        cli_utilities_1.log.debug(`JSON reference check passed`);
         return true;
     }
     /**
@@ -1127,41 +1520,63 @@ class Entries {
      * schemas.
      */
     async prepareEntryMetaData() {
-        this.log(messages_1.auditMsg.PREPARING_ENTRY_METADATA, 'info');
+        cli_utilities_1.log.debug('Starting entry metadata preparation');
+        cli_utilities_1.log.info(messages_1.auditMsg.PREPARING_ENTRY_METADATA);
         const localesFolderPath = (0, path_1.resolve)(this.config.basePath, this.config.moduleConfig.locales.dirName);
         const localesPath = (0, path_1.join)(localesFolderPath, this.config.moduleConfig.locales.fileName);
         const masterLocalesPath = (0, path_1.join)(localesFolderPath, 'master-locale.json');
+        cli_utilities_1.log.debug(`Loading locales from: ${masterLocalesPath}`);
         this.locales = (0, fs_1.existsSync)(masterLocalesPath) ? (0, values_1.default)(JSON.parse((0, fs_1.readFileSync)(masterLocalesPath, 'utf8'))) : [];
+        cli_utilities_1.log.debug(`Loaded ${this.locales.length} master locales`);
+        cli_utilities_1.log.debug(`Loading additional locales from: ${localesPath}`);
         if ((0, fs_1.existsSync)(localesPath)) {
-            this.locales.push(...(0, values_1.default)(JSON.parse((0, fs_1.readFileSync)(localesPath, 'utf8'))));
+            const additionalLocales = (0, values_1.default)(JSON.parse((0, fs_1.readFileSync)(localesPath, 'utf8')));
+            this.locales.push(...additionalLocales);
+            cli_utilities_1.log.debug(`Added ${additionalLocales.length} additional locales`);
+        }
+        else {
+            cli_utilities_1.log.debug('No additional locales file found');
         }
         const environmentPath = (0, path_1.resolve)(this.config.basePath, this.config.moduleConfig.environments.dirName, this.config.moduleConfig.environments.fileName);
+        cli_utilities_1.log.debug(`Loading environments from: ${environmentPath}`);
         this.environments = (0, fs_1.existsSync)(environmentPath) ? (0, lodash_1.keys)(JSON.parse((0, fs_1.readFileSync)(environmentPath, 'utf8'))) : [];
+        cli_utilities_1.log.debug(`Loaded ${this.environments.length} environments: ${this.environments.join(', ')}`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Processing ${this.locales.length} locales and ${this.ctSchema.length} content types for entry metadata`, this.config.auditContext);
         for (const { code } of this.locales) {
+            cli_utilities_1.log.debug(`Processing locale: ${code}`, this.config.auditContext);
             for (const { uid } of this.ctSchema) {
+                cli_utilities_1.log.debug(`Processing content type: ${uid} in locale ${code}`, this.config.auditContext);
                 let basePath = (0, path_1.join)(this.folderPath, uid, code);
+                cli_utilities_1.log.debug(`Entry base path: ${basePath}`, this.config.auditContext);
                 let fsUtility = new cli_utilities_1.FsUtility({ basePath, indexFileName: 'index.json' });
                 let indexer = fsUtility.indexFileContent;
+                cli_utilities_1.log.debug(`Found ${Object.keys(indexer).length} entry files for ${uid}/${code}`, this.config.auditContext);
                 for (const _ in indexer) {
                     const entries = (await fsUtility.readChunkFiles.next());
+                    cli_utilities_1.log.debug(`Processing ${Object.keys(entries).length} entries from file`, this.config.auditContext);
                     for (const entryUid in entries) {
                         let { title } = entries[entryUid];
+                        cli_utilities_1.log.debug(`Processing entry metadata: ${entryUid} (${title || 'no title'})`, this.config.auditContext);
                         if (entries[entryUid].hasOwnProperty('title') && !title) {
+                            cli_utilities_1.log.debug(`Entry ${entryUid} has empty title field`, this.config.auditContext);
                             this.missingTitleFields[entryUid] = {
                                 'Entry UID': entryUid,
                                 'Content Type UID': uid,
                                 Locale: code,
                             };
-                            this.log(`The 'title' field in Entry with UID '${entryUid}' of Content Type '${uid}' in Locale '${code}' is empty.`, `error`);
+                            cli_utilities_1.log.info(`The 'title' field in Entry with UID '${entryUid}' of Content Type '${uid}' in Locale '${code}' is empty.`, this.config.auditContext);
                         }
                         else if (!title) {
-                            this.log(`The 'title' field in Entry with UID '${entryUid}' of Content Type '${uid}' in Locale '${code}' is empty.`, `error`);
+                            cli_utilities_1.log.debug(`Entry ${entryUid} has no title field`, this.config.auditContext);
+                            cli_utilities_1.log.debug(`The 'title' field in Entry with UID '${entryUid}' of Content Type '${uid}' in Locale '${code}' is empty.`, this.config.auditContext);
                         }
                         this.entryMetaData.push({ uid: entryUid, title, ctUid: uid });
                     }
                 }
             }
         }
+        cli_utilities_1.log.debug(`Entry metadata preparation completed: ${this.entryMetaData.length} entries processed`, this.config.auditContext);
+        cli_utilities_1.log.debug(`Missing title fields found: ${Object.keys(this.missingTitleFields).length}`, this.config.auditContext);
     }
 }
 exports.default = Entries;