sfdx-hardis 6.5.0 → 6.5.2

package/CHANGELOG.md

@@ -4,6 +4,18 @@
 
 Note: Can be used with `sfdx plugins:install sfdx-hardis@beta` and docker image `hardisgroupcom/sfdx-hardis@beta`
 
+- Display alias is org selection
+
+## [6.5.1] 2025-09-20
+
+- [hardis:org:monitor:backup](https://sfdx-hardis.cloudity.com/hardis/org/monitor/backup/) enhancements:
+  - Creates the 'force-app/main/default' directory if it doesn't exist before retrieving metadatas
+- [hardis:org:configure:monitoring](https://sfdx-hardis.cloudity.com/hardis/org/configure/monitoring/):
+  - Display the connected App XML in logs (while hiding sensitive info)
+  - When production org, run the first found test class (or allow to force its selection using ENV variable `SFDX_HARDIS_TECH_DEPLOY_TEST_CLASS` )
+  - Add instructions to use ghcr.io Docker image in case of rate limits reached on Docker Hub
+- Handle progress component in UI when generating documentation
+
 ## [6.5.0] 2025-09-17
 
 - Files export enhancements:

package/defaults/ci/.gitlab-ci.yml

@@ -20,7 +20,7 @@ stages:
 
 # Jobs are run on sfdx-hardis image, that includes all required dependencies.
 # You can use latest, beta or latest-recommended
-image: hardisgroupcom/sfdx-hardis:latest
+image: hardisgroupcom/sfdx-hardis:latest # If rate limits reached, use ghcr.io/hardisgroupcom/sfdx-hardis:latest
 
 # Force color for output logs for better readability
 variables:

package/defaults/ci/Jenkinsfile

@@ -54,7 +54,8 @@ pipeline {
             stage('Validation') {
                 agent {
                     docker {
-                        image 'hardisgroupcom/sfdx-hardis:latest'
+                        // If rate limits reached, use ghcr.io/hardisgroupcom/sfdx-hardis:latest
+                        image 'hardisgroupcom/sfdx-hardis:latest' 
                     }
                 }
                 when { changeRequest() }
@@ -74,6 +75,7 @@ pipeline {
             stage('Deployment') {
                 agent {
                     docker {
+                        // If rate limits reached, use ghcr.io/hardisgroupcom/sfdx-hardis:latest
                         image 'hardisgroupcom/sfdx-hardis:latest'
                     }
                 }

package/defaults/lintonly/.gitlab-ci.yml

@@ -7,7 +7,7 @@ stages:
 
 # On execute les jobs sur l'image hardisgroupcom/sfdx-hardis qui contient les applications necessaires
 # Version latest recommandée, cependant beta et alpha peuvent être utilisées pour les tests
-image: hardisgroupcom/sfdx-hardis:latest
+image: hardisgroupcom/sfdx-hardis:latest # If rate limits reached, use ghcr.io/hardisgroupcom/sfdx-hardis:latest
 
 # Variables globales aux jobs
 variables:

package/defaults/monitoring/.gitlab-ci.yml

@@ -16,7 +16,7 @@ stages:
   - monitor
 
 # Use sfdx-hardis docker image to always be up to date with latest version
-image: hardisgroupcom/sfdx-hardis:latest # test with alpha
+image: hardisgroupcom/sfdx-hardis:latest # If rate limits reached, use ghcr.io/hardisgroupcom/sfdx-hardis:latest
 
 ##############################################
 ### Sfdx Sources Backup + Push new commit ####

package/lib/commands/hardis/doc/project2markdown.js

@@ -261,7 +261,7 @@ ${this.htmlInstructions}
         await fs.writeFile(path.join(this.outputMarkdownRoot, "manifests.md"), getMetaHideLines() + packageLines.join("\n") + `\n${this.footer}\n`);
         this.tempDir = await createTempDir();
         // Convert source to metadata API format to build prompts
-        uxLog("action", this, c.cyan("Converting source to metadata API format..."));
+        uxLog("action", this, c.cyan("Converting source to metadata API format to ease the build of LLM prompts..."));
         await execCommand(`sf project convert source --metadata CustomObject --output-dir ${this.tempDir}`, this, { fail: true, output: true, debug: this.debugMode });
         this.objectFiles = (await glob("**/*.object", { cwd: this.tempDir, ignore: GLOB_IGNORE_PATTERNS }));
         sortCrossPlatform(this.objectFiles);
@@ -351,7 +351,7 @@ ${Project2Markdown.htmlInstructions}
         return { outputPackageXmlMarkdownFiles: this.outputPackageXmlMarkdownFiles };
     }
     async generateApexDocumentation() {
-        uxLog("action", this, c.cyan("Generating Apex documentation... (if you don't want it, define GENERATE_APEX_DOC=false in your environment variables)"));
+        uxLog("action", this, c.cyan("Calling ApexDocGen to initialize Apex documentation... (if you don't want it, define GENERATE_APEX_DOC=false in your environment variables)"));
         const tempDir = await createTempDir();
         uxLog("log", this, c.grey(`Using temp directory ${tempDir}`));
         const packageDirs = this.project?.getPackageDirectories() || [];
@@ -396,7 +396,13 @@ ${Project2Markdown.htmlInstructions}
             });
         }
         // Complete generated documentation
+        if (apexFiles.length === 0) {
+            uxLog("log", this, c.yellow("No Apex class found in the project"));
+            return;
+        }
         const apexForMenu = { "All Apex Classes": "apex/index.md" };
+        WebSocketClient.sendProgressStartMessage("Generating Apex documentation...", apexFiles.length);
+        let counter = 0;
         for (const apexFile of apexFiles) {
             const apexName = path.basename(apexFile, ".cls").replace(".trigger", "");
             const apexContent = await fs.readFile(apexFile, "utf8");
@@ -431,7 +437,10 @@ ${Project2Markdown.htmlInstructions}
                     await generatePdfFileFromMarkdown(mdFile);
                 }
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, apexFiles.length);
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Apex", apexForMenu);
         // Write index file for apex folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "apex"));
@@ -439,7 +448,6 @@ ${Project2Markdown.htmlInstructions}
         await fs.writeFile(apexIndexFile, getMetaHideLines() + DocBuilderApex.buildIndexTable('', this.apexDescriptions).join("\n") + `\n\n${this.footer}\n`);
     }
     async generatePackagesDocumentation() {
-        uxLog("action", this, c.cyan("Generating Installed Packages documentation..."));
         const packagesForMenu = { "All Packages": "packages/index.md" };
         // List packages
         const packages = this.sfdxHardisConfig.installedPackages || []; // CI/CD context
@@ -456,6 +464,8 @@ ${Project2Markdown.htmlInstructions}
                 packages.push(pckg);
             }
         }
+        WebSocketClient.sendProgressStartMessage("Generating Installed Packages documentation...", packages.length);
+        let counter = 0;
         // Process packages
         for (const pckg of packages) {
             const packageName = pckg.SubscriberPackageName;
@@ -491,17 +501,22 @@ ${Project2Markdown.htmlInstructions}
             if (mdFileBad !== mdFile && fs.existsSync(mdFileBad)) {
                 await fs.remove(mdFileBad);
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, packages.length);
         }
         this.addNavNode("Packages", packagesForMenu);
         // Write index file for packages folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "packages"));
         const packagesIndexFile = path.join(this.outputMarkdownRoot, "packages", "index.md");
         await fs.writeFile(packagesIndexFile, getMetaHideLines() + DocBuilderPackage.buildIndexTable('', this.packageDescriptions).join("\n") + `\n\n${this.footer}\n`);
+        WebSocketClient.sendProgressEndMessage();
     }
     async generatePagesDocumentation() {
         const packageDirs = this.project?.getPackageDirectories() || [];
         const pageFiles = await listPageFiles(packageDirs);
         const pagesForMenu = { "All Lightning pages": "pages/index.md" };
+        WebSocketClient.sendProgressStartMessage("Generating Lightning Pages documentation...", pageFiles.length);
+        let counter = 0;
         for (const pagefile of pageFiles) {
             const pageName = path.basename(pagefile, ".flexipage-meta.xml");
             const mdFile = path.join(this.outputMarkdownRoot, "pages", pageName + ".md");
@@ -518,7 +533,10 @@ ${Project2Markdown.htmlInstructions}
             if (this.withPdf) {
                 await generatePdfFileFromMarkdown(mdFile);
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, pageFiles.length);
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Lightning Pages", pagesForMenu);
         // Write index file for pages folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "pages"));
@@ -526,10 +544,16 @@ ${Project2Markdown.htmlInstructions}
         await fs.writeFile(pagesIndexFile, getMetaHideLines() + DocBuilderPage.buildIndexTable('', this.pageDescriptions).join("\n") + `\n\n${this.footer}\n`);
     }
     async generateProfilesDocumentation() {
-        uxLog("action", this, c.cyan("Generating Profiles documentation... (if you don't want it, define GENERATE_PROFILES_DOC=false in your environment variables)"));
+        uxLog("action", this, c.cyan("Preparing generation of Profiles documentation... (if you don't want it, define GENERATE_PROFILES_DOC=false in your environment variables)"));
         const profilesForMenu = { "All Profiles": "profiles/index.md" };
         const profilesFiles = (await glob("**/profiles/**.profile-meta.xml", { cwd: process.cwd(), ignore: GLOB_IGNORE_PATTERNS }));
         sortCrossPlatform(profilesFiles);
+        if (profilesFiles.length === 0) {
+            uxLog("log", this, c.yellow("No profile found in the project"));
+            return;
+        }
+        WebSocketClient.sendProgressStartMessage("Generating Profiles documentation...", profilesFiles.length);
+        let counter = 0;
         for (const profileFile of profilesFiles) {
             const profileName = path.basename(profileFile, ".profile-meta.xml");
             const mdFile = path.join(this.outputMarkdownRoot, "profiles", profileName + ".md");
@@ -546,7 +570,10 @@ ${Project2Markdown.htmlInstructions}
             if (this.withPdf) {
                 await generatePdfFileFromMarkdown(mdFile);
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, profilesFiles.length);
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Profiles", profilesForMenu);
         // Write index file for profiles folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "profiles"));
@@ -554,10 +581,16 @@ ${Project2Markdown.htmlInstructions}
         await fs.writeFile(profilesIndexFile, getMetaHideLines() + DocBuilderProfile.buildIndexTable('', this.profileDescriptions).join("\n") + `\n\n${this.footer}\n`);
     }
     async generatePermissionSetsDocumentation() {
-        uxLog("action", this, c.cyan("Generating Permission Sets documentation... (if you don't want it, define GENERATE_PROFILES_DOC=false in your environment variables)"));
+        uxLog("action", this, c.cyan("Preparing generation of Permission Sets documentation... (if you don't want it, define GENERATE_PROFILES_DOC=false in your environment variables)"));
         const psForMenu = { "All Permission Sets": "permissionsets/index.md" };
         const psFiles = (await glob("**/permissionsets/**.permissionset-meta.xml", { cwd: process.cwd(), ignore: GLOB_IGNORE_PATTERNS }));
         sortCrossPlatform(psFiles);
+        if (psFiles.length === 0) {
+            uxLog("log", this, c.yellow("No permission set found in the project"));
+            return;
+        }
+        WebSocketClient.sendProgressStartMessage("Generating Permission Sets documentation...", psFiles.length);
+        let counter = 0;
         for (const psFile of psFiles) {
             const psName = path.basename(psFile, ".permissionset-meta.xml");
             const mdFile = path.join(this.outputMarkdownRoot, "permissionsets", psName + ".md");
@@ -577,7 +610,10 @@ ${Project2Markdown.htmlInstructions}
             if (this.withPdf) {
                 await generatePdfFileFromMarkdown(mdFile);
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, psFiles.length);
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Permission Sets", psForMenu);
         // Write index file for permission sets folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "permissionsets"));
@@ -585,10 +621,16 @@ ${Project2Markdown.htmlInstructions}
         await fs.writeFile(psIndexFile, getMetaHideLines() + DocBuilderPermissionSet.buildIndexTable('', this.permissionSetsDescriptions).join("\n") + `\n\n${this.footer}\n`);
     }
     async generatePermissionSetGroupsDocumentation() {
-        uxLog("action", this, c.cyan("Generating Permission Set Groups documentation..."));
+        uxLog("action", this, c.cyan("Preparing generation of Permission Set Groups documentation..."));
         const psgForMenu = { "All Permission Set Groups": "permissionsetgroups/index.md" };
         const psgFiles = (await glob("**/permissionsetgroups/**.permissionsetgroup-meta.xml", { cwd: process.cwd(), ignore: GLOB_IGNORE_PATTERNS }));
         sortCrossPlatform(psgFiles);
+        if (psgFiles.length === 0) {
+            uxLog("log", this, c.yellow("No permission set group found in the project"));
+            return;
+        }
+        WebSocketClient.sendProgressStartMessage("Generating Permission Set Groups documentation...", psgFiles.length);
+        let counter = 0;
         for (const psgFile of psgFiles) {
             const psgName = path.basename(psgFile, ".permissionsetgroup-meta.xml");
             const mdFile = path.join(this.outputMarkdownRoot, "permissionsetgroups", psgName + ".md");
@@ -608,7 +650,10 @@ ${Project2Markdown.htmlInstructions}
             if (this.withPdf) {
                 await generatePdfFileFromMarkdown(mdFile);
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, psgFiles.length);
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Permission Set Groups", psgForMenu);
         // Write index file for permission set groups folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "permissionsetgroups"));
@@ -619,6 +664,10 @@ ${Project2Markdown.htmlInstructions}
         uxLog("action", this, c.cyan("Generating Roles documentation... (if you don't want it, define GENERATE_PROFILES_DOC=false in your environment variables)"));
         const roleFiles = (await glob("**/roles/**.role-meta.xml", { cwd: process.cwd(), ignore: GLOB_IGNORE_PATTERNS }));
         sortCrossPlatform(roleFiles);
+        if (roleFiles.length === 0) {
+            uxLog("log", this, c.yellow("No role found in the project"));
+            return;
+        }
         for (const roleFile of roleFiles) {
             const roleApiName = path.basename(roleFile, ".role-meta.xml");
             const roleXml = await fs.readFile(roleFile, "utf8");
@@ -639,7 +688,7 @@ ${Project2Markdown.htmlInstructions}
         }
     }
     async generateAssignmentRulesDocumentation() {
-        uxLog("action", this, c.cyan("Generating Assignment Rules documentation... " +
+        uxLog("action", this, c.cyan("Preparing generation of Assignment Rules documentation... " +
             "(if you don't want it, define GENERATE_AUTOMATIONS_DOC=false in your environment variables)"));
         const assignmentRulesForMenu = { "All Assignment Rules": "assignmentRules/index.md" };
         const assignmentRulesFiles = (await glob("**/assignmentRules/**.assignmentRules-meta.xml", {
@@ -648,6 +697,23 @@ ${Project2Markdown.htmlInstructions}
         }));
         sortCrossPlatform(assignmentRulesFiles);
         const builder = new XMLBuilder();
+        // Count total rules for progress tracking
+        let totalRules = 0;
+        for (const assignmentRulesFile of assignmentRulesFiles) {
+            const assignmentRulesXml = await fs.readFile(assignmentRulesFile, "utf8");
+            const assignmentRulesXmlParsed = new XMLParser().parse(assignmentRulesXml);
+            let rulesList = assignmentRulesXmlParsed?.AssignmentRules?.assignmentRule || [];
+            if (!Array.isArray(rulesList)) {
+                rulesList = [rulesList];
+            }
+            totalRules += rulesList.length;
+        }
+        if (totalRules === 0) {
+            uxLog("log", this, c.yellow("No assignment rule found in the project"));
+            return;
+        }
+        WebSocketClient.sendProgressStartMessage("Generating Assignment Rules documentation...", totalRules);
+        let counter = 0;
         for (const assignmentRulesFile of assignmentRulesFiles) {
             const assignmentRulesXml = await fs.readFile(assignmentRulesFile, "utf8");
             const assignmentRulesXmlParsed = new XMLParser().parse(assignmentRulesXml);
@@ -670,15 +736,18 @@ ${Project2Markdown.htmlInstructions}
                 if (this.withPdf) {
                     await generatePdfFileFromMarkdown(mdFile);
                 }
+                counter++;
+                WebSocketClient.sendProgressStepMessage(counter, totalRules);
             }
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Assignment Rules", assignmentRulesForMenu);
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "assignmentRules"));
         const psgIndexFile = path.join(this.outputMarkdownRoot, "assignmentRules", "index.md");
         await fs.writeFile(psgIndexFile, getMetaHideLines() + DocBuilderAssignmentRules.buildIndexTable('', this.assignmentRulesDescriptions).join("\n") + `\n${this.footer}\n`);
     }
     async generateApprovalProcessDocumentation() {
-        uxLog("action", this, c.cyan("Generating Approval Processes documentation... " +
+        uxLog("action", this, c.cyan("Preparing generation of Approval Processes documentation... " +
             "(if you don't want it, define GENERATE_AUTOMATIONS_DOC=false in your environment variables)"));
         const approvalProcessesForMenu = { "All Approval Processes": "approvalProcesses/index.md" };
         const approvalProcessFiles = (await glob("**/approvalProcesses/**.approvalProcess-meta.xml", {
@@ -686,6 +755,12 @@ ${Project2Markdown.htmlInstructions}
             ignore: GLOB_IGNORE_PATTERNS
         }));
         sortCrossPlatform(approvalProcessFiles);
+        if (approvalProcessFiles.length === 0) {
+            uxLog("log", this, c.yellow("No approval process found in the project"));
+            return;
+        }
+        WebSocketClient.sendProgressStartMessage("Generating Approval Processes documentation...", approvalProcessFiles.length);
+        let counter = 0;
         for (const approvalProcessFile of approvalProcessFiles) {
             const approvalProcessName = path.basename(approvalProcessFile, ".approvalProcess-meta.xml");
             const mdFile = path.join(this.outputMarkdownRoot, "approvalProcesses", approvalProcessName + ".md");
@@ -701,14 +776,17 @@ ${Project2Markdown.htmlInstructions}
             if (this.withPdf) {
                 await generatePdfFileFromMarkdown(mdFile);
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, approvalProcessFiles.length);
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Approval Processes", approvalProcessesForMenu);
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "approvalProcesses"));
         const approvalProcessesIndexFile = path.join(this.outputMarkdownRoot, "approvalProcesses", "index.md");
         await fs.writeFile(approvalProcessesIndexFile, getMetaHideLines() + DocBuilderApprovalProcess.buildIndexTable('', this.approvalProcessesDescriptions).join("\n") + `\n\n${this.footer}\n`);
     }
     async generateAutoResponseRulesDocumentation() {
-        uxLog("action", this, c.cyan("Generating AutoResponse Rules documentation... " +
+        uxLog("action", this, c.cyan("Preparing generation of AutoResponse Rules documentation... " +
             "(if you don't want it, define GENERATE_AUTOMATIONS_DOC=false in your environment variables)"));
         const autoResponseRulesForMenu = { "All AutoResponse Rules": "autoResponseRules/index.md" };
         const autoResponseRulesFiles = (await glob("**/autoResponseRules/**.autoResponseRules-meta.xml", {
@@ -717,6 +795,23 @@ ${Project2Markdown.htmlInstructions}
         }));
         sortCrossPlatform(autoResponseRulesFiles);
         const builder = new XMLBuilder();
+        // Count total rules for progress tracking
+        let totalRules = 0;
+        for (const autoResponseRulesFile of autoResponseRulesFiles) {
+            const autoResponseRulesXml = await fs.readFile(autoResponseRulesFile, "utf8");
+            const autoResponseRulesXmlParsed = new XMLParser().parse(autoResponseRulesXml);
+            let rulesList = autoResponseRulesXmlParsed?.AutoResponseRules?.autoResponseRule || [];
+            if (!Array.isArray(rulesList)) {
+                rulesList = [rulesList];
+            }
+            totalRules += rulesList.length;
+        }
+        if (totalRules === 0) {
+            uxLog("log", this, c.yellow("No auto-response rules found in the project"));
+            return;
+        }
+        WebSocketClient.sendProgressStartMessage("Generating AutoResponse Rules documentation...", totalRules);
+        let counter = 0;
         for (const autoResponseRulesFile of autoResponseRulesFiles) {
             const autoResponseRulesXml = await fs.readFile(autoResponseRulesFile, "utf8");
             const autoResponseRulesXmlParsed = new XMLParser().parse(autoResponseRulesXml);
@@ -739,8 +834,11 @@ ${Project2Markdown.htmlInstructions}
                 if (this.withPdf) {
                     await generatePdfFileFromMarkdown(mdFile);
                 }
+                counter++;
+                WebSocketClient.sendProgressStepMessage(counter, totalRules);
             }
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("AutoResponse Rules", autoResponseRulesForMenu);
         // Write index file for permission set groups folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "autoResponseRules"));
@@ -748,7 +846,7 @@ ${Project2Markdown.htmlInstructions}
         await fs.writeFile(psgIndexFile, getMetaHideLines() + DocBuilderAutoResponseRules.buildIndexTable('', this.autoResponseRulesDescriptions).join("\n") + `\n${this.footer}\n`);
     }
     async generateEscalationRulesDocumentation() {
-        uxLog("action", this, c.cyan("Generating Escalation Rules documentation... " +
+        uxLog("action", this, c.cyan("Preparing generation of Escalation Rules documentation... " +
             "(if you don't want it, define GENERATE_AUTOMATIONS_DOC=false in your environment variables)"));
         const escalationRulesForMenu = { "All Escalation Rules": "escalationRules/index.md" };
         const escalationRulesFiles = (await glob("**/escalationRules/**.escalationRules-meta.xml", {
@@ -757,6 +855,23 @@ ${Project2Markdown.htmlInstructions}
         }));
         sortCrossPlatform(escalationRulesFiles);
         const builder = new XMLBuilder();
+        // Count total rules for progress tracking
+        let totalRules = 0;
+        for (const escalationRulesFile of escalationRulesFiles) {
+            const escalationRulesXml = await fs.readFile(escalationRulesFile, "utf8");
+            const escalationRulesXmlParsed = new XMLParser().parse(escalationRulesXml);
+            let rulesList = escalationRulesXmlParsed?.EscalationRules?.escalationRule || [];
+            if (!Array.isArray(rulesList)) {
+                rulesList = [rulesList];
+            }
+            totalRules += rulesList.length;
+        }
+        if (totalRules === 0) {
+            uxLog("log", this, c.yellow("No escalation rules found in the project"));
+            return;
+        }
+        WebSocketClient.sendProgressStartMessage("Generating Escalation Rules documentation...", totalRules);
+        let counter = 0;
         for (const escalationRulesFile of escalationRulesFiles) {
             const escalationRulesXml = await fs.readFile(escalationRulesFile, "utf8");
             const escalationRulesXmlParsed = new XMLParser().parse(escalationRulesXml);
@@ -767,6 +882,8 @@ ${Project2Markdown.htmlInstructions}
                 rulesList = [rulesList];
             }
             for (const rule of rulesList) {
+                counter++;
+                WebSocketClient.sendProgressStepMessage(counter);
                 const currentRuleName = escalationRulesName + "." + rule?.fullName;
                 escalationRulesForMenu[currentRuleName] = "escalationRules/" + currentRuleName + ".md";
                 const mdFile = path.join(this.outputMarkdownRoot, "escalationRules", currentRuleName + ".md");
@@ -781,6 +898,7 @@ ${Project2Markdown.htmlInstructions}
                 }
             }
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Escalation Rules", escalationRulesForMenu);
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "escalationRules"));
         const psgIndexFile = path.join(this.outputMarkdownRoot, "escalationRules", "index.md");
@@ -924,14 +1042,18 @@ ${Project2Markdown.htmlInstructions}
         uxLog("action", this, c.cyan(`To generate a HTML WebSite with this documentation with a single command, see instructions at ${CONSTANTS.DOC_URL_ROOT}/hardis/doc/project2markdown/`));
     }
     async generateObjectsDocumentation() {
-        uxLog("action", this, c.cyan("Generating Objects AI documentation... (if you don't want it, define GENERATE_OBJECTS_DOC=false in your environment variables)"));
+        uxLog("action", this, c.cyan("Preparing generation of Objects AI documentation... (if you don't want it, define GENERATE_OBJECTS_DOC=false in your environment variables)"));
         const objectLinksInfo = await this.generateLinksInfo();
         const objectsForMenu = { "All objects": "objects/index.md" };
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "objects"));
+        WebSocketClient.sendProgressStartMessage("Generating Objects documentation...", this.objectFiles.length);
+        let counter = 0;
         for (const objectFile of this.objectFiles) {
             const objectName = path.basename(objectFile, ".object");
             if ((objectName.endsWith("__dlm") || objectName.endsWith("__dll")) && !(process.env?.INCLUDE_DATA_CLOUD_DOC === "true")) {
                 uxLog("log", this, c.grey(`Skip Data Cloud Object ${objectName}... (use INCLUDE_DATA_CLOUD_DOC=true to enforce it)`));
+                counter++;
+                WebSocketClient.sendProgressStepMessage(counter, this.objectFiles.length);
                 continue;
             }
             uxLog("log", this, c.grey(`Generating markdown for Object ${objectName}...`));
@@ -989,7 +1111,10 @@ ${Project2Markdown.htmlInstructions}
             if (this.withPdf) {
                 await generatePdfFileFromMarkdown(objectMdFile);
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, this.objectFiles.length);
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Objects", objectsForMenu);
         // Write index file for objects folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "objects"));
@@ -1005,7 +1130,7 @@ ${Project2Markdown.htmlInstructions}
         await replaceInFile(objectMdFile, '<!-- Attributes tables -->', attributesMarkdown);
     }
     async generateLinksInfo() {
-        uxLog("action", this, c.cyan("Generate MasterDetail and Lookup infos to provide context to AI prompt"));
+        uxLog("log", this, c.cyan("Generate MasterDetail and Lookup infos to provide context to AI prompt"));
         const findFieldsPattern = `**/objects/**/fields/**.field-meta.xml`;
         const matchingFieldFiles = (await glob(findFieldsPattern, { cwd: process.cwd(), ignore: GLOB_IGNORE_PATTERNS })).map(file => file.replace(/\\/g, '/'));
         const customFieldsLinks = [];
@@ -1022,7 +1147,7 @@ ${Project2Markdown.htmlInstructions}
         return customFieldsLinks.join("\n") + "\n";
     }
     async generateFlowsDocumentation() {
-        uxLog("action", this, c.cyan("Generating Flows Visual documentation... (if you don't want it, define GENERATE_FLOW_DOC=false in your environment variables)"));
+        uxLog("action", this, c.cyan("Preparing generation of Flows Visual documentation... (if you don't want it, define GENERATE_FLOW_DOC=false in your environment variables)"));
         const flowsForMenu = { "All flows": "flows/index.md" };
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "flows"));
         const packageDirs = this.project?.getPackageDirectories();
@@ -1043,7 +1168,13 @@ ${Project2Markdown.htmlInstructions}
             const extractedNames = [...flowXml.matchAll(regex)].map(match => match[1]);
             flowDeps[flowName] = extractedNames;
         }
+        if (flowFiles.length === 0) {
+            uxLog("log", this, c.yellow("No flow found in the project"));
+            return;
+        }
         // Generate Flows documentation
+        WebSocketClient.sendProgressStartMessage("Generating Flows documentation...", flowFiles.length);
+        let counter = 0;
         for (const flowFile of flowFiles) {
             const flowName = path.basename(flowFile, ".flow-meta.xml");
             const flowXml = (await fs.readFile(flowFile, "utf8")).toString();
@@ -1059,12 +1190,16 @@ ${Project2Markdown.htmlInstructions}
             const outputFlowMdFile = path.join(this.outputMarkdownRoot, "flows", flowName + ".md");
             if (this.diffOnly && !updatedFlowNames.includes(flowName) && fs.existsSync(outputFlowMdFile)) {
                 flowSkips.push(flowFile);
+                counter++;
+                WebSocketClient.sendProgressStepMessage(counter, flowFiles.length);
                 continue;
             }
             uxLog("log", this, c.grey(`Generating markdown for Flow ${flowFile}...`));
             const genRes = await generateFlowMarkdownFile(flowName, flowXml, outputFlowMdFile, { collapsedDetails: false, describeWithAi: true, flowDependencies: flowDeps });
             if (!genRes) {
                 flowErrors.push(flowFile);
+                counter++;
+                WebSocketClient.sendProgressStepMessage(counter, flowFiles.length);
                 continue;
             }
             if (this.debugMode) {
@@ -1073,17 +1208,25 @@ ${Project2Markdown.htmlInstructions}
             const gen2res = await generateMarkdownFileWithMermaid(outputFlowMdFile, outputFlowMdFile, null, this.withPdf);
             if (!gen2res) {
                 flowWarnings.push(flowFile);
+                counter++;
+                WebSocketClient.sendProgressStepMessage(counter, flowFiles.length);
                 continue;
             }
+            counter++;
+            WebSocketClient.sendProgressStepMessage(counter, flowFiles.length);
         }
+        WebSocketClient.sendProgressEndMessage();
         this.flowDescriptions = sortArray(this.flowDescriptions, { by: ['object', 'name'], order: ['asc', 'asc'] });
         // History
         if (this.withHistory) {
-            uxLog("action", this, c.cyan("Generating Flows Visual Git Diff History documentation..."));
+            WebSocketClient.sendProgressStartMessage("Generating Flows History documentation...", flowFiles.length);
+            let counter1 = 0;
             for (const flowFile of flowFiles) {
                 const flowName = path.basename(flowFile, ".flow-meta.xml");
                 const diffMdFile = path.join("docs", "flows", path.basename(flowFile).replace(".flow-meta.xml", "-history.md"));
                 if (this.diffOnly && !updatedFlowNames.includes(flowName) && fs.existsSync(diffMdFile)) {
+                    counter1++;
+                    WebSocketClient.sendProgressStepMessage(counter1, flowFiles.length);
                     continue;
                 }
                 try {
@@ -1092,7 +1235,10 @@ ${Project2Markdown.htmlInstructions}
                 catch (e) {
                     uxLog("warning", this, c.yellow(`Error generating history diff markdown: ${e.message}`));
                 }
+                counter1++;
+                WebSocketClient.sendProgressStepMessage(counter1, flowFiles.length);
             }
+            WebSocketClient.sendProgressEndMessage();
         }
         // Summary
         if (flowSkips.length > 0) {
@@ -1217,11 +1363,26 @@ ${Project2Markdown.htmlInstructions}
         }
     }
     async generateLwcDocumentation() {
-        uxLog("action", this, c.cyan("Generating Lightning Web Components documentation... " +
+        uxLog("action", this, c.cyan("Preparing generation of Lightning Web Components documentation... " +
             "(if you don't want it, define GENERATE_LWC_DOC=false in your environment variables)"));
         const lwcForMenu = { "All Lightning Web Components": "lwc/index.md" };
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "lwc"));
         const packageDirs = this.project?.getPackageDirectories() || [];
+        // Count total LWC components for progress tracking
+        let totalLwcComponents = 0;
+        for (const packageDir of packageDirs) {
+            const lwcMetaFiles = await glob(`${packageDir.path}/**/lwc/**/*.js-meta.xml`, {
+                cwd: process.cwd(),
+                ignore: GLOB_IGNORE_PATTERNS
+            });
+            totalLwcComponents += lwcMetaFiles.length;
+        }
+        if (totalLwcComponents === 0) {
+            uxLog("log", this, c.yellow("No Lightning Web Component found in the project"));
+            return;
+        }
+        WebSocketClient.sendProgressStartMessage("Generating Lightning Web Components documentation...", totalLwcComponents);
+        let counter = 0;
         // Find all LWC components in all package directories
         for (const packageDir of packageDirs) {
             // Find LWC components (directories with .js-meta.xml files)
@@ -1230,6 +1391,8 @@ ${Project2Markdown.htmlInstructions}
                 ignore: GLOB_IGNORE_PATTERNS
             });
             for (const lwcMetaFile of lwcMetaFiles) {
+                counter++;
+                WebSocketClient.sendProgressStepMessage(counter);
                 const lwcDirPath = path.dirname(lwcMetaFile);
                 const lwcName = path.basename(lwcDirPath);
                 const mdFile = path.join(this.outputMarkdownRoot, "lwc", lwcName + ".md");
@@ -1274,6 +1437,7 @@ ${Project2Markdown.htmlInstructions}
                 }
             }
         }
+        WebSocketClient.sendProgressEndMessage();
         this.addNavNode("Lightning Web Components", lwcForMenu);
         // Write index file for LWC folder
         await fs.ensureDir(path.join(this.outputMarkdownRoot, "lwc"));