@zohodesk/codestandard-validator 0.0.6-exp-20 → 0.0.6-exp-21

package/build/hooks/Precommit/pre-commit.js

@@ -1,409 +1,310 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = validateRemotePackages;
-// const {exec, execSync} = require('child_process')
-// const fs = require('fs')
-// const path = require('path')
-// const { getEslintExecutablePath } = require('../../utils/ConfigFileUtils/getEslintExecutablePath')
-// const { getNodeModulesPath } = require('../../utils/General/getNodeModulesPath')
-// const { filterFiles, filterWarningInFile } = require('../../utils/FileAndFolderOperations/filterFiles')
-// const { Logger } = require('../../utils/Logger/Logger')
-// const { checkIfPluginsAreInstalled } = require('../../utils/PluginsInstallation/checkIfPluginsAreInstalled')
-// const { getBranchName } = require('../../utils/GitActions/gitActions')
-// const { getConfigurationPrecommit, getSupportedLanguage  } = require('../../utils/General/getGeneralInfo')
-// const { getRootDirectory } = require('../../utils/General/RootDirectoryUtils/getRootDirectory')
-// const { impactBasedPrecommit, shouldWarningsAbortCommit } = getConfigurationPrecommit()
-
-// /**
-//  * @function isMergeCommit - This method check whether it is merge or not
-//  * @returns {Boolean} -  return boolean based on latest merge changes
-//  */
-// async function isMergeCommit() {
-//     return new Promise((resolve, reject) => {
-//         exec('git rev-parse -q --verify MERGE_HEAD', (error,stderr,stdout) => {
-//             if(error){
-//                 reject(error.toString().trim())
-//             }
-//             else if(stderr){
-//                 resolve(stderr.trim())
-//             }
-//             else if(stdout){
-//                 resolve(stdout.trim())
-//             }
-//         })
-//     })
-
-// }
-
-// /**
-//  * @function {getStagedFiles} - methods return staged files
-//  * @returns {Array<string>} -  array of  files
-//  */
-
-// async function getStagedFiles(){
-//     return new Promise((resolve, reject) => {
-//         exec("git diff --staged --name-only",(error,stderr,stdout) =>{
-//            if (error){
-//             if(error != null)
-//             reject("Couldn't fetch staged files")
-//            }
-//            else if(stderr){
-//             resolve(filterDeltedFileFromStagedFiles(stderr.trim().split('\n')))
-//            }
-//            else if(stdout.trim() === ''){
-//             resolve(stdout.trim())
-//            }
-//         })
-//     })
-
-// }
-
-// /**
-//  * @function {filterDeltedFileFromStagedFiles} - filter deleted staged files
-//  * @param {Array<string>} files - staged files
-//  * @returns 
-//  */
-// function filterDeltedFileFromStagedFiles(files){
-//     return files.filter((file) =>{
-//         const absolutePath= path.resolve(getRootDirectory(),file)
-//         if(fs.existsSync(absolutePath)){
-//             return true
-//         }
-//         return false
-//     })
-// }
-
-// async function lintFiles(filePath){
-//     switch(path.extname(filePath)){
-//         case '.js' ||'.ts' || '.tsx' || '.jsx' : {
-//             return await findEslintErrors(filePath    )
-//         }
-
-//         case '.css' || '.scss' :{
-//             return await findStyleLintErrors(filePath)
-//         }
-//         default : {
-//             return []
-//         }
-//     }
-// }
-
-// /**
-//  * @function findEslintErrors - method  Lint given file based on given configuration
-//  * @param {*} file - path of file to lint
-//  * @returns {Array<string>} -  array of command line report as a string 
-//  */
-
-//  function findEslintErrors(file){
-//     let nodeModulesPathOfProject = `${getNodeModulesPath()}`
-//     let eslintExecutablePath = getEslintExecutablePath()
-//     let eslintConfigurationFilePath = `${nodeModulesPathOfProject}/.eslintrc.js`
-//     let isEslintExecutablePresent = fs.existsSync(eslintExecutablePath) ? true : false
-//     let isNodeModulesPresent = fs.existsSync(nodeModulesPathOfProject)
-
-//     if(isNodeModulesPresent){
-//         if(isEslintExecutablePresent){
-//             return new Promise ((resolve, reject) => {
-//                 exec(`npx --ignore-existing "${eslintExecutablePath}" --config "${eslintConfigurationFilePath}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPathOfProject}/node_modules" ${file}`,(error,stderr,stdout) => {
-//                     if(stderr){
-//                         resolve(stderr.trim().split('\n'))
-//                     }
-//                     else if(error){
-//                         Logger.log(Logger.FAILURE_TYPE,error)
-//                         reject("Error executing eslint command")
-//                     }
-//                     else{
-//                         resolve([])
-//                     }
-//                 })
-//             })
-//         }
-//         else{
-//             Logger.log(Logger.INFO_TYPE,'Eslint executable not found. make sure eslint plugin is installed')
-//         }
-//     }
-//     else{
-//         Logger.log(Logger.INFO_TYPE,'node_modules not found')
-//     }
-// }
-
-// /**
-//  * 
-//  * @param {*} params 
-//  */
-//  function findStyleLintErrors(filePath) {
-//     const configFilePath = path.resolve(getNodeModulesPath(),'.stylelintrc.json')
-//     const absolutePath = path.join(getRootDirectory(),filePath)
-//     try{
-//         return new Promise ((resolve, reject) => {
-//             exec(`npx stylelint ${absolutePath} --config ${configFilePath}`,{cwd:getNodeModulesPath()},(error,stderr,stdout) => {
-//                 if(stderr){
-//                     resolve(stderr.trim().split('\n'))
-//                 }
-//                 else if(error){
-//                     Logger.log(Logger.FAILURE_TYPE,error)
-//                     reject("Error executing eslint command")
-//                 }
-//                 else{
-//                     resolve([])
-//                 }
-//             })
-//         })
-//     }catch(error){
-//         Logger.log(Logger.FAILURE_TYPE,`Issue is lint css files`)
-//         return []
-//     }
-// }
-
-// /**
-//  * @function {calculateGitDiffForFile} -  method calculate diff of file
-//  * @param {*} branch_name - branch name
-//  * @param {*} file - path of file
-//  * @returns {Promise<Array<string>>} - array of command line report as a string 
-//  */
-// async function calculateGitDiffForFile(branch_name,file){
-//     let gitDiffCommand = `git diff -U0 ${branch_name.trim()} ${file}`
-//     return new Promise ((resolve,reject) => {        
-//         exec(gitDiffCommand,(error, stderr) => {
-//             if(stderr){
-//                 resolve(stderr.trim().split('\n'))
-//             }
-//             else if(error) {
-//                 reject(error)
-//             }
-//         })
-//     })
-// }
-// /**
-//  * @function {areAllPluginsInstalled} -  method whether plugin is installed or not
-//  * @returns {Boolean} - return boolean based on plugin installed or not
-//  */
-
-// function areAllPluginsInstalled(){
-//     let unInstalledPlugins = checkIfPluginsAreInstalled().uninstalledPlugins
-//     return unInstalledPlugins.length === 0 ? true : false
-// }
-
-// /**
-//  * @function {isOnlyWarningsPresentInFile} - method that checks if only eslint warnings are present in a file
-//  * @returns {Boolean} - returns boolean based on only warnings present or not in file
-//  */
-// function isOnlyWarningsPresentInFile(eslintErrorsPresent){
-//     let severityOfEachErrorInFile = []
-//     eslintErrorsPresent.map(error => {
-//         let partsInString = error.split(" ")
-//         let severityOfError = partsInString.find(word => word === 'error' || word === 'warning'|| word === '✖')
-//         severityOfEachErrorInFile.push(severityOfError)
-//     })
-//     return  !(severityOfEachErrorInFile.includes('✖') || severityOfEachErrorInFile.includes('error'))
-// }
-
-// /**
-//  * @function {preCommitHook} - method execute pre commit hook
-//  * @returns {void}
-//  */
+const {
+  exec
+} = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const {
+  getEslintExecutablePath
+} = require('../../utils/EslintConfigFileUtils/getEslintExecutablePath');
+const {
+  getNodeModulesPath
+} = require('../../utils/General/getNodeModulesPath');
+const {
+  filterFiles,
+  filterWarningInFile
+} = require('../../utils/FileAndFolderOperations/filterFiles');
+const {
+  Logger
+} = require('../../utils/Logger/Logger');
+const {
+  checkIfPluginsAreInstalled
+} = require('../../utils/PluginsInstallation/checkIfPluginsAreInstalled');
+const {
+  getBranchName
+} = require('../../utils/GitActions/gitActions');
+const {
+  getConfigurationPrecommit,
+  getSupportedLanguage
+} = require('../../utils/General/getGeneralInfo');
+const {
+  getRootDirectory
+} = require('../../utils/General/RootDirectoryUtils/getRootDirectory');
+const {
+  impactBasedPrecommit,
+  shouldWarningsAbortCommit
+} = getConfigurationPrecommit();
 
-// async function preCommitHook() {
-//     Logger.log(Logger.INFO_TYPE,'Executing pre commit hook...')
-//     Logger.log(Logger.INFO_TYPE,`working dir  : ${process.cwd()}`)
-//     try{
-//         let isMerge = await isMergeCommit();
-//         Logger.log(Logger.INFO_TYPE,'Looks like you have merged. So skipping pre commit check');
-//         process.exit(0);
-//     }
-//     catch(error){
-//         if(areAllPluginsInstalled()){
-//             let staged_files = []
-//             let eslintConfigFiles = ['.eslintrc.js']
-//             let exemptionFiles = []
-//             let current_branch = ''
-//             let hasEslintErrorsInChangedLines = false
-//             let hasEslintErrorsInFiles = false
-//             let areFilesStaged = false
-//             let shouldAbortCommit = false
-//             try{
-//                 current_branch = await getBranchName()
-//             }
-//             catch{
-//                 Logger.log(Logger.INFO_TYPE,"Error fetching current branch")
-//             }
-//             try{
-//                 staged_files = await getStagedFiles()
+/**
+ * @function isMergeCommit - This method check whether it is merge or not
+ * @returns {Boolean} -  return boolean based on latest merge changes
+ */
+async function isMergeCommit() {
+  return new Promise((resolve, reject) => {
+    exec('git rev-parse -q --verify MERGE_HEAD', (error, stderr, stdout) => {
+      if (error) {
+        reject(error.toString().trim());
+      } else if (stderr) {
+        resolve(stderr.trim());
+      } else if (stdout) {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
 
-//                 if(!staged_files.length == 0){
-//                     const {JsFiles:staged_filesJS, CssFiles} = filterFiles(staged_files,eslintConfigFiles,true)
+/**
+ * @function {getStagedFiles} - methods return staged files
+ * @returns {Array<string>} -  array of  files
+ */
 
-//                     // staged_filesJS = filterFiles(staged_filesJS,exemptionFiles) //this is the code for giving exemption to a file during pre commit
-//                     // if(staged_filesJS.length === 0){
-//                     //     Logger.log(Logger.SUCCESS_TYPE,`Commit Successful`)
-//                     //     process.exit(0)
-//                     // }
-//                     areFilesStaged = true
-//                     var stagedFiles = [...staged_filesJS,...CssFiles]
-//                     for (let file in stagedFiles){
-//                         let currentFileName = stagedFiles[file]
-//                         let changedLinesArray = []
-//                         let eslintErrorsInChangedLines = []
-//                         let isOnlyEslintWarningsPresentInFile = false
+async function getStagedFiles() {
+  return new Promise((resolve, reject) => {
+    exec("git diff --staged --name-only", (error, stderr, stdout) => {
+      if (error) {
+        if (error != null) reject("Couldn't fetch staged files");
+      } else if (stderr) {
+        resolve(filterDeltedFileFromStagedFiles(stderr.trim().split('\n')));
+      } else if (stdout.trim() === '') {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
 
-//                         if(getSupportedLanguage().includes(path.extname(stagedFiles[file]) )){
-//                             try{
-//                                 var errorsInFile= await lintFiles(stagedFiles[file])
-//                                 // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(errorsInFile) : errorsInFile
-//                                 if(stagedFiles[file] && typeof(stagedFiles[file]) == 'string'){
-//                                     if(! errorsInFile.length == 0){
-//                                         //Calculating changed lines in a file and storing them in respective arrays
-//                                         if(impactBasedPrecommit) {
+/**
+ * @function {filterDeltedFileFromStagedFiles} - filter deleted staged files
+ * @param {Array<string>} files - staged files
+ * @returns 
+ */
+function filterDeltedFileFromStagedFiles(files) {
+  return files.filter(file => {
+    const absolutePath = path.resolve(getRootDirectory(), file);
+    if (fs.existsSync(absolutePath)) {
+      return true;
+    }
+    return false;
+  });
+}
 
-//                                             //git diff is computed and stored in an array
-//                                             let git_diff = await calculateGitDiffForFile(current_branch,stagedFiles[file])
-//                                             changedLinesArray = git_diff.filter((line) => line.startsWith('@@'))
+/**
+ * @function findEslintErrors - method  Lint given file based on given configuration
+ * @param {*} file - path of file to lint
+ * @returns {Array<string>} -  array of command line report as a string 
+ */
 
-//                                             let changedLinesStartArray = []
-//                                             let changedLinesEndArray = []
+async function findEslintErrors(file) {
+  let nodeModulesPathOfProject = `${getNodeModulesPath()}`;
+  let eslintExecutablePath = getEslintExecutablePath();
+  let eslintConfigurationFilePath = `${nodeModulesPathOfProject}/.eslintrc.js`;
+  let isEslintExecutablePresent = fs.existsSync(eslintExecutablePath) ? true : false;
+  let isNodeModulesPresent = fs.existsSync(nodeModulesPathOfProject);
+  if (isNodeModulesPresent) {
+    if (isEslintExecutablePresent) {
+      return new Promise((resolve, reject) => {
+        exec(`npx --ignore-existing "${eslintExecutablePath}" --config "${eslintConfigurationFilePath}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPathOfProject}/node_modules" ${file}`, (error, stderr, stdout) => {
+          if (stderr) {
+            resolve(stderr.trim().split('\n'));
+          } else if (error) {
+            Logger.log(Logger.FAILURE_TYPE, error);
+            reject("Error executing eslint command");
+          } else {
+            resolve([]);
+          }
+        });
+      });
+    } else {
+      Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. make sure eslint plugin is installed');
+    }
+  } else {
+    Logger.log(Logger.INFO_TYPE, 'node_modules not found');
+  }
+}
+/**
+ * @function {calculateGitDiffForFile} -  method calculate diff of file
+ * @param {*} branch_name - branch name
+ * @param {*} file - path of file
+ * @returns {Promise<Array<string>>} - array of command line report as a string 
+ */
+async function calculateGitDiffForFile(branch_name, file) {
+  let gitDiffCommand = `git diff -U0 ${branch_name.trim()} ${file}`;
+  return new Promise((resolve, reject) => {
+    exec(gitDiffCommand, (error, stderr) => {
+      if (stderr) {
+        resolve(stderr.trim().split('\n'));
+      } else if (error) {
+        reject(error);
+      }
+    });
+  });
+}
+/**
+ * @function {areAllPluginsInstalled} -  method whether plugin is installed or not
+ * @returns {Boolean} - return boolean based on plugin installed or not
+ */
 
-//                                             for (let number of changedLinesArray){
-//                                                 let changesStartLine = parseInt(number.split(' ')[2].split(',')[0])
-//                                                 changedLinesStartArray.push(changesStartLine)
-//                                                 let changesEndLine = number.split(' ')[2].split(',')[1]
-//                                                 if(changesEndLine === undefined){
-//                                                     changedLinesEndArray.push(changesStartLine)
-//                                                 }
-//                                                 else{
-//                                                     changedLinesEndArray.push(changesStartLine + parseInt(changesEndLine) - 1)
-//                                                 }
-//                                             }
-//                                             for (let error=1; error < errorsInFile.length - 2; error++){
-//                                                 //errorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
-//                                                 //errorsInFile[error].trim().split(' ')[0] => 69:26
-//                                                 //errorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
+function areAllPluginsInstalled() {
+  let unInstalledPlugins = checkIfPluginsAreInstalled().uninstalledPlugins;
+  return unInstalledPlugins.length === 0 ? true : false;
+}
 
-//                                                 let eslintErrorLineNumber = errorsInFile[error].trim().split(' ')[0].split(':')[0]
+/**
+ * @function {isOnlyWarningsPresentInFile} - method that checks if only eslint warnings are present in a file
+ * @returns {Boolean} - returns boolean based on only warnings present or not in file
+ */
+function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
+  let severityOfEachErrorInFile = [];
+  eslintErrorsPresent.map(error => {
+    let partsInString = error.split(" ");
+    let severityOfError = partsInString.find(word => word === 'error' || word === 'warning');
+    severityOfEachErrorInFile.push(severityOfError);
+  });
+  return !severityOfEachErrorInFile.includes('error');
+}
 
-//                                                 for(let lineNumber in changedLinesStartArray){
-//                                                     if(eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && 
-//                                                         eslintErrorLineNumber <= changedLinesEndArray[lineNumber]){
-//                                                             eslintErrorsInChangedLines.push(errorsInFile[error])
-//                                                         }
-//                                                 }
-//                                             }
-//                                             if(eslintErrorsInChangedLines.length > 0){
-//                                                 isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(eslintErrorsInChangedLines)
-//                                                 Logger.log(Logger.FAILURE_TYPE,`\x1b[1m${currentFileName}\x1b[0m`)
-//                                                 for(let eslintError of eslintErrorsInChangedLines){
-//                                                     Logger.log(Logger.FAILURE_TYPE,`\x1b[37m${eslintError.trimEnd()}\x1b[0m`)
-//                                                 }
-//                                                 if(shouldWarningsAbortCommit){
-//                                                     hasEslintErrorsInChangedLines = true
-//                                                     shouldAbortCommit = true
-//                                                 }
-//                                                 else if(!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile){
-//                                                     hasEslintErrorsInChangedLines = false
-//                                                 }
-//                                                 else if(!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile){
-//                                                     hasEslintErrorsInChangedLines = true
-//                                                     shouldAbortCommit = true
-//                                                 }
-//                                             }  
-//                                         }else{
-//                                             if(errorsInFile.length > 0 ){
-//                                                 let startIndex = 1
-//                                                 let endIndex = errorsInFile.length - 2
-//                                                 let listOsEslintErrors = errorsInFile.slice(startIndex,endIndex)
-//                                                 isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(listOsEslintErrors)
-//                                                 Logger.log(Logger.FAILURE_TYPE,`\x1b[1m${currentFileName}\x1b[0m`)
-//                                                 for(let eslintError of listOsEslintErrors){
-//                                                     Logger.log(Logger.FAILURE_TYPE,`\x1b[37m${eslintError.trimEnd()}\x1b[0m`)
-//                                                 }
-//                                                 if(shouldWarningsAbortCommit){
-//                                                     hasEslintErrorsInFiles = true
-//                                                     shouldAbortCommit = true
-//                                                 }
-//                                                 else if(!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile){
-//                                                     hasEslintErrorsInFiles = false
-//                                                 }
-//                                                 else if(!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile){
-//                                                     hasEslintErrorsInFiles = true
-//                                                     shouldAbortCommit = true
-//                                                 }
-//                                             }
-//                                         }
-//                                     }
-//                                 } 
-//                             }
-//                             catch(err){
-//                                 Logger.log(Logger.FAILURE_TYPE,err)
-//                                 Logger.log(Logger.FAILURE_TYPE,"Error in executing eslint command")
-//                             }
+/**
+ * @function {preCommitHook} - method execute pre commit hook
+ * @returns {void}
+ */
 
-//                         }
-//                     }
-//                 }
-//                 else if(staged_files.length === 0){
-//                     Logger.log(Logger.INFO_TYPE,'No files have been staged. Stage your files before committing')
-//                 }
-//             }
-//             catch{
-//                 Logger.log(Logger.INFO_TYPE,'Error executing pre commit hook')
-//             }
-//             if(shouldAbortCommit){
-//                 Logger.log(Logger.FAILURE_TYPE, `There are eslint errors/warnings present. So commit is aborted.`);
-//                 process.exit(1);
-//             }
-//             else if(shouldAbortCommit === false && staged_files.length !== 0){
-//                 Logger.log(Logger.SUCCESS_TYPE, `Commit Successful`);
-//                 process.exit(0);
-//             }
-//         }
-//         else{
-//             Logger.log(Logger.FAILURE_TYPE,'Commit failed since some eslint plugins are not installed')
-//             Logger.log(Logger.INFO_TYPE,`Kindly execute the command \x1b[37mnpx ZDPrecommit setupPlugins \x1b[33mfrom the location where package.json is present to install the plugins`)
-//             Logger.log(Logger.INFO_TYPE,'Execute the command and kindly try committing again.')
-//             process.exit(1)
-//         }
-//     }
-// }
+async function preCommitHook() {
+  Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
+  Logger.log(Logger.INFO_TYPE, `working dir  : ${process.cwd()}`);
+  try {
+    let isMerge = await isMergeCommit();
+    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
+    process.exit(0);
+  } catch (error) {
+    if (areAllPluginsInstalled()) {
+      let staged_files = [];
+      let eslintConfigFiles = ['.eslintrc.js'];
+      let exemptionFiles = [];
+      let current_branch = '';
+      let hasEslintErrorsInChangedLines = false;
+      let hasEslintErrorsInFiles = false;
+      let areFilesStaged = false;
+      let shouldAbortCommit = false;
+      try {
+        current_branch = await getBranchName();
+      } catch {
+        Logger.log(Logger.INFO_TYPE, "Error fetching current branch");
+      }
+      try {
+        staged_files = await getStagedFiles();
+        if (!staged_files.length == 0) {
+          staged_files = filterFiles(staged_files, eslintConfigFiles, true);
 
-// preCommitHook()
+          // staged_files = filterFiles(staged_files,exemptionFiles) //this is the code for giving exemption to a file during pre commit
+          // if(staged_files.length === 0){
+          //     Logger.log(Logger.SUCCESS_TYPE,`Commit Successful`)
+          //     process.exit(0)
+          // }
+          areFilesStaged = true;
+          for (let file in staged_files) {
+            let currentFileName = staged_files[file];
+            let changedLinesArray = [];
+            let eslintErrorsInChangedLines = [];
+            let isOnlyEslintWarningsPresentInFile = false;
+            if (getSupportedLanguage().includes(path.extname(staged_files[file]))) {
+              try {
+                var eslintErrorsInFile = await findEslintErrors(staged_files[file]);
+                // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(eslintErrorsInFile) : eslintErrorsInFile
+                if (staged_files[file] && typeof staged_files[file] == 'string') {
+                  if (!eslintErrorsInFile.length == 0) {
+                    //Calculating changed lines in a file and storing them in respective arrays
+                    if (impactBasedPrecommit) {
+                      //git diff is computed and stored in an array
+                      let git_diff = await calculateGitDiffForFile(current_branch, staged_files[file]);
+                      changedLinesArray = git_diff.filter(line => line.startsWith('@@'));
+                      let changedLinesStartArray = [];
+                      let changedLinesEndArray = [];
+                      for (let number of changedLinesArray) {
+                        let changesStartLine = parseInt(number.split(' ')[2].split(',')[0]);
+                        changedLinesStartArray.push(changesStartLine);
+                        let changesEndLine = number.split(' ')[2].split(',')[1];
+                        if (changesEndLine === undefined) {
+                          changedLinesEndArray.push(changesStartLine);
+                        } else {
+                          changedLinesEndArray.push(changesStartLine + parseInt(changesEndLine) - 1);
+                        }
+                      }
+                      for (let error = 1; error < eslintErrorsInFile.length - 2; error++) {
+                        //eslintErrorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
+                        //eslintErrorsInFile[error].trim().split(' ')[0] => 69:26
+                        //eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
 
-const {
-  getNodeModulesPath
-} = require("../../utils/General/getNodeModulesPath");
-const {
-  cloneViaCdt
-} = require("../../utils/CloneCommonLinterRepo/cloneViaCdt");
-const {
-  createConfigFiles
-} = require("../../utils/ConfigFileUtils/createConfigFiles");
-const {
-  getLastCommitHash,
-  getStoredCommitHash
-} = require("../../utils/General/getGeneralInfo");
-const {
-  execSync
-} = require("child_process");
-const {
-  Logger
-} = require("../../utils/Logger/Logger");
-async function validateRemotePackages() {
-  try {
-    if (!(getStoredCommitHash() == getLastCommitHash())) {
-      await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
-      await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createConfigFiles, null);
-      Logger.log(Logger.SUCCESS_TYPE, "Pre commit setup successfull");
+                        let eslintErrorLineNumber = eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0];
+                        for (let lineNumber in changedLinesStartArray) {
+                          if (eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && eslintErrorLineNumber <= changedLinesEndArray[lineNumber]) {
+                            eslintErrorsInChangedLines.push(eslintErrorsInFile[error]);
+                          }
+                        }
+                      }
+                      if (eslintErrorsInChangedLines.length > 0) {
+                        isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(eslintErrorsInChangedLines);
+                        Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
+                        for (let eslintError of eslintErrorsInChangedLines) {
+                          Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${eslintError.trimEnd()}\x1b[0m`);
+                        }
+                        if (shouldWarningsAbortCommit) {
+                          hasEslintErrorsInChangedLines = true;
+                          shouldAbortCommit = true;
+                        } else if (!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInChangedLines = false;
+                        } else if (!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInChangedLines = true;
+                          shouldAbortCommit = true;
+                        }
+                      }
+                    } else {
+                      if (eslintErrorsInFile.length > 0) {
+                        let startIndex = 1;
+                        let endIndex = eslintErrorsInFile.length - 2;
+                        let listOsEslintErrors = eslintErrorsInFile.slice(startIndex, endIndex);
+                        isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(listOsEslintErrors);
+                        Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
+                        for (let eslintError of listOsEslintErrors) {
+                          Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${eslintError.trimEnd()}\x1b[0m`);
+                        }
+                        if (shouldWarningsAbortCommit) {
+                          hasEslintErrorsInFiles = true;
+                          shouldAbortCommit = true;
+                        } else if (!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInFiles = false;
+                        } else if (!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInFiles = true;
+                          shouldAbortCommit = true;
+                        }
+                      }
+                    }
+                  }
+                }
+              } catch (err) {
+                Logger.log(Logger.FAILURE_TYPE, err);
+                Logger.log(Logger.FAILURE_TYPE, "Error in executing eslint command");
+              }
+            }
+          }
+        } else if (staged_files.length === 0) {
+          Logger.log(Logger.INFO_TYPE, 'No files have been staged. Stage your files before committing');
+        }
+      } catch {
+        Logger.log(Logger.INFO_TYPE, 'Error executing pre commit hook');
+      }
+      if (shouldAbortCommit) {
+        Logger.log(Logger.FAILURE_TYPE, `There are eslint errors/warnings present. So commit is aborted.`);
+        process.exit(1);
+      } else if (shouldAbortCommit === false && staged_files.length !== 0) {
+        Logger.log(Logger.SUCCESS_TYPE, `Commit Successful`);
+        process.exit(0);
+      }
+    } else {
+      Logger.log(Logger.FAILURE_TYPE, 'Commit failed since some eslint plugins are not installed');
+      Logger.log(Logger.INFO_TYPE, `Kindly execute the command \x1b[37mnpx ZDPrecommit setupPlugins \x1b[33mfrom the location where package.json is present to install the plugins`);
+      Logger.log(Logger.INFO_TYPE, 'Execute the command and kindly try committing again.');
+      process.exit(1);
     }
-    execSync("npx ZDPrecommit setupPlugins", {
-      cwd: getNodeModulesPath()
-    });
-  } catch (error) {
-    Logger.log(Logger.FAILURE_TYPE, `Kindly retry npm install. & ${error.message}`);
   }
 }
-async function lint() {
-  await validateRemotePackages();
-  require("./lint");
-}
-lint();
+preCommitHook();

package/build/lib/cli.js

@@ -13,11 +13,11 @@ const {
   installEslintExtension
 } = require("../utils/ExtensionInstallation/installEslintExtension");
 const {
-  Logger
-} = require("../utils/Logger/Logger");
+  installPlugins
+} = require("../utils/PluginsInstallation/installPlugins");
 const {
-  arePluginsInstalled
-} = require("../utils/PluginsInstallation/arePluginsInstalled");
+  checkIfPluginsAreInstalled
+} = require("../utils/PluginsInstallation/checkIfPluginsAreInstalled");
 const [,, action, ...options] = process.argv;
 async function run() {
   switch (action) {
@@ -33,7 +33,10 @@ async function run() {
       }
     case "setupPlugins":
       {
-        arePluginsInstalled();
+        const {
+          uninstalledPlugins
+        } = checkIfPluginsAreInstalled();
+        await executeMethodsThatReturnBooleanValue("Some issue occurred in installing plugins", installPlugins, uninstalledPlugins);
         break;
       }
     case "setupExtension":
@@ -43,7 +46,6 @@ async function run() {
       }
     default:
       {
-        Logger.log(Logger.FAILURE_TYPE, `oops! command not supported :( ...`);
         break;
       }
   }

package/build/lib/postinstall.js

@@ -7,8 +7,8 @@ const {
   setupHusky
 } = require("../utils/HuskySetup/setupHusky");
 const {
-  createConfigFiles
-} = require("../utils/ConfigFileUtils/createConfigFiles");
+  createEslintConfigFile
+} = require("../utils/EslintConfigFileUtils/createEslintConfigFile");
 const {
   Logger
 } = require("../utils/Logger/Logger");
@@ -34,9 +34,9 @@ async function postInstall() {
     await executeMethodsThatReturnBooleanValue("Some issue in writing node_modules path to json", writeFsPaths, null);
     isGitInitialized() ? await executeMethodsThatReturnBooleanValue("Some issue occurred in setting up husky.", setupHusky, null) : null;
     await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
-    await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createConfigFiles, null);
+    await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createEslintConfigFile, null);
     Logger.log(Logger.SUCCESS_TYPE, "Pre commit setup successfull");
-    // arePluginsInstalled();
+    arePluginsInstalled();
   } catch (error) {
     Logger.log(Logger.FAILURE_TYPE, `Kindly retry npm install. & ${error.message}`);
   }

package/build/utils/CloneCommonLinterRepo/cloneViaCdt.js

@@ -51,7 +51,7 @@ function cloneViaCdt() {
     Logger.log(Logger.INFO_TYPE, `Running in ${runningEnv}`);
     absoluteEndPoint = `https://${userName}:${decrypt(token, process.env.DECRYPT_TOKEN)}@${endPoint}`;
   }
-  var commandToCloneCommonConfigRepo = `npx cdt clone --clone:type=${type} --clone:url=${absoluteEndPoint} --clone:branch=${branch} --clone:cacheDir=${cacheDirectory} --clone:proj:name=${commonLinterRepoName}`;
+  var commandToCloneCommonConfigRepo = `npx cdt clone --clone:type=${type} --clone:url=${absoluteEndPoint} --clone:branch=${process.env.CONFIGURATION_BRANCH || branch} --clone:cacheDir=${cacheDirectory} --clone:proj:name=${commonLinterRepoName}`;
   let isCommonConfigurationClonedSuccessfully = executeSynchronizedCommands(execSync, [commandToCloneCommonConfigRepo, {
     cwd: getClonedDirPath()
   }], `Lint Configuration Cloned Successfully - ${getRepoName() || 'common'}`, 'Could not clone the linters common repo', false, true);

package/build/utils/FileAndFolderOperations/filterFiles.js

@@ -3,9 +3,7 @@
 const {
   Logger
 } = require('../Logger/Logger');
-const {
-  existsSync
-} = require("fs");
+
 /**
  * @function filterFiles - removes certain files from set of source files
  * @param {Array} arrayOfFilesToBeFiltered - array of files which must be filtered 
@@ -14,29 +12,6 @@ const {
  * @returns {Array} - containing the resultant set of files after filtering
  */
 function filterFiles(arrayOfFilesToBeFiltered, filesToBeRemoved, isConfigFileNeedToBeRemoved = false) {
-  /**
-   * @function filterFilesByExtension - filter javascript files. omit feature files
-   * @param {Array<String>} lintFiles - linter files as Array
-   * @returns {Array<String>} 
-   * */
-  function filterFilesByExtension(lintFiles) {
-    return lintFiles.reduce((files, currentFile) => {
-      if (currentFile.includes('.feature') && existsSync(currentFile)) {
-        files.featureFiles.push(currentFile);
-      }
-      if (currentFile.includes('.js') || currentFile.includes('.ts') || currentFile.includes('.tsx') || currentFile.includes('.jsx') && existsSync(currentFile)) {
-        files.JsFiles.push(currentFile);
-      }
-      if (currentFile.includes('.css') || currentFile.includes('.scss') && existsSync(currentFile)) {
-        files.CssFiles.push(currentFile);
-      }
-      return files;
-    }, {
-      featureFiles: [],
-      JsFiles: [],
-      CssFiles: []
-    });
-  }
   if (filesToBeRemoved.length !== 0) {
     if (isConfigFileNeedToBeRemoved) {
       arrayOfFilesToBeFiltered.filter(file => {
@@ -56,7 +31,7 @@ function filterFiles(arrayOfFilesToBeFiltered, filesToBeRemoved, isConfigFileNee
         return false;
       }
     });
-    return filterFilesByExtension(filteredArrayofFilesWithoutConfigFile);
+    return filteredArrayofFilesWithoutConfigFile;
   } else if (filesToBeRemoved.length === 0) {
     return arrayOfFilesToBeFiltered;
   }

package/build/utils/FileAndFolderOperations/versionControl.js

@@ -16,13 +16,14 @@ const {
 function createVersionControlFile(uninstalledPlugins) {
   Logger.log(Logger.INFO_TYPE, `Rule Plugin Versions are Noted in pluginVersionControl.js`);
   const versionfilePath = path.join(getNodeModulesPath(), 'node_modules', '@zohodesk', 'codestandard-validator', 'pluginVersionControl.js');
-  existsSync(versionfilePath) && writeFileSync(versionfilePath, '');
-  writeFileSync(versionfilePath, `module.exports.plugins = [${uninstalledPlugins.map(plugin => {
-    return JSON.stringify({
-      plugin: `${plugin}`,
-      time: `${new Date()}`
-    });
-  }).join(',')}]`);
+  if (existsSync(versionfilePath)) {
+    writeFileSync(versionfilePath, `module.exports.plugins = [${uninstalledPlugins.map(plugin => {
+      return JSON.stringify({
+        plugin: `${plugin}`,
+        time: `${new Date()}`
+      });
+    }).join(',')}]`);
+  }
 }
 module.exports = {
   createVersionControlFile

package/build/utils/General/getGeneralInfo.js

@@ -6,19 +6,11 @@ const fs = require("fs");
 const {
   execSync
 } = require('child_process');
-const {
-  Logger
-} = require('../Logger/Logger');
-const {
-  readOnlyToken,
-  commitHashEndPoint
-} = require('../../../jsonUtils/commonLinterRepoDetails');
 
 /**
  * @function getTimeStampInfo - to fetch various timestamp details
  * @returns {object} - each property of the object denotes various timestamp details
  */
-
 function getTimeStampInfo() {
   const date = new Date();
   return {
@@ -35,7 +27,6 @@ function getTimeStampInfo() {
  * @function getEnv - to fetch the os type
  * @returns {string} - indicates the os
  */
-
 function getEnv() {
   return os.type();
 }
@@ -44,7 +35,6 @@ function getEnv() {
  * @function getConfigPath - get a path of lint configuration path
  * @returns {string}
  */
-
 function getConfigPath() {
   const configPath = path.resolve(process.cwd(), 'lint.config.js');
   const defaultConfigPath = path.resolve(__dirname, '..', '..', 'setup', 'sample.config.js');
@@ -55,27 +45,19 @@ function getConfigPath() {
  * @function getConfiguration - get configuration object of lint configuration
  * @returns
  */
-
 function getConfigurationPrecommit() {
   return require(getConfigPath());
 }
 
 /**
- * @function getRunningEnv - Retrieves the current running environment by executing the `npm config get lint_env` command.
- * @returns {string} The current lint environment value set in the npm config.
+ * @function getSupportedLanguage - get support language
+ * @returns {Array<string>}
  */
-
 function getSupportedLanguage() {
   const {
     supportedExtensions
   } = getConfigurationPrecommit();
   const _language = supportedExtensions;
-  _language.push('.js');
-  _language.push('.jsx');
-  _language.push('.ts');
-  _language.push('.tsx');
-  _language.push('.css');
-  _language.push('.scss');
   return _language;
 }
 function getRunningEnv() {
@@ -84,51 +66,10 @@ function getRunningEnv() {
     shell: true
   }).toString().trim();
 }
-
-/**
- * @function getLastCommitHash - Fetches the last commit hash from a GitLab project using its API.
- * 
- * @note This function assumes access to a specific GitLab instance and a hardcoded token and project ID.
- * @returns {string} The latest commit hash (SHA) from the specified GitLab repository.
- * @throws {Error} Will throw an error if the API request fails or returns unexpected data.
- */
-
-function getLastCommitHash() {
-  try {
-    const cmd = `curl --header "PRIVATE-TOKEN: ${readOnlyToken}" --url ${commitHashEndPoint}`;
-    return JSON.parse(execSync(cmd))[0].id;
-  } catch (err) {
-    Logger.log(Logger.FAILURE_TYPE, err);
-    return null;
-  }
-}
-
-/**
- * @function getRequiredInfoPath - Returns the absolute path to the `fsUtils.json` file located in the `jsonUtils` directory at the project root.
- * @returns {string} The full path to the `fsUtils.json` file.
- */
-
-function getRequiredInfoPath() {
-  return path.join(process.cwd(), 'jsonUtils', 'fsUtils.json');
-}
-
-/**
- * @function getStoredCommitHash - Loads and returns the stored commit hash from `fsUtils.json`.
- * @returns {string} The commit hash stored in the `fsUtils.json` file.
- * @throws {Error} Will throw if the file does not exist or does not contain a `commitHash` key.
- */
-
-function getStoredCommitHash() {
-  const commitInfoPath = path.join(__dirname, '..', '..', '..', 'jsonUtils', 'fsUtils.json');
-  return fs.existsSync(commitInfoPath) && require(commitInfoPath).commitHash;
-}
 module.exports = {
   getSupportedLanguage,
   getTimeStampInfo,
   getEnv,
   getConfigurationPrecommit,
-  getRunningEnv,
-  getLastCommitHash,
-  getRequiredInfoPath,
-  getStoredCommitHash
+  getRunningEnv
 };

package/build/utils/General/writeProjectDetailsToJson.js

@@ -7,16 +7,11 @@ const {
 const {
   executeSynchronizedCommands
 } = require('./executeSyncCommands');
-const {
-  getLastCommitHash,
-  getRequiredInfoPath
-} = require('./getGeneralInfo');
 function writeFsPaths() {
   var fileContent = {
-    nodeModulesPath: path.resolve(process.cwd(), '..', '..', '..'),
-    commitHash: getLastCommitHash()
+    nodeModulesPath: path.resolve(process.cwd(), '..', '..', '..')
   };
-  return executeSynchronizedCommands(writeFileSync, [getRequiredInfoPath(), JSON.stringify(fileContent), 'utf-8'], 'node_modules path updated in json file', 'Unable to write node_modules path to json file', false, true);
+  return executeSynchronizedCommands(writeFileSync, [path.join(process.cwd(), 'jsonUtils', 'fsUtils.json'), JSON.stringify(fileContent), 'utf-8'], 'node_modules path updated in json file', 'Unable to write node_modules path to json file', false, true);
 }
 module.exports = {
   writeFsPaths

package/build/utils/PluginsInstallation/arePluginsInstalled.js

@@ -1,20 +1,24 @@
 "use strict";
 
-const {
-  executeMethodsThatReturnBooleanValue
-} = require('../General/wrapperFunctionToExecuteAFunction');
 const {
   checkIfPluginsAreInstalled
 } = require('./checkIfPluginsAreInstalled');
+const {
+  printUninstalledPlugins
+} = require('./printUninstalledPlugins');
 const {
   installPlugins
 } = require('./installPlugins');
-async function arePluginsInstalled() {
+function arePluginsInstalled() {
   let {
     uninstalledPlugins,
     noPluginMessage
   } = checkIfPluginsAreInstalled();
-  await executeMethodsThatReturnBooleanValue("Some issue occurred in installing plugins", installPlugins, uninstalledPlugins);
+  let areAllPluginsInstalled = uninstalledPlugins.length === 0 ? true : false;
+  if (!areAllPluginsInstalled) {
+    installPlugins(uninstalledPlugins);
+  }
+  // printUninstalledPlugins(uninstalledPlugins,noPluginMessage)
 }
 module.exports = {
   arePluginsInstalled

package/build/utils/PluginsInstallation/checkIfPluginsAreInstalled.js

@@ -1,15 +1,22 @@
 "use strict";
 
 const {
+  readdirSync,
   existsSync
 } = require('fs');
 const path = require('path');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath');
 const {
   Logger
 } = require('../Logger/Logger');
 const {
   getLibraryInstalledLocation
 } = require('../General/getLibraryInstalledLocation');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
 const {
   endPoint,
   commonLinterRepoName
@@ -19,7 +26,33 @@ const {
 } = require('../General/wrapperFunctionToExecuteAFunction');
 const {
   getServicePathElseCommon
-} = require('../ConfigFileUtils/getLintConfiguration');
+} = require('../EslintConfigFileUtils/getLintConfiguration');
+function getUnInstalledPlugins(pluginsForCurrentRepo, pluginNamesOfDevDependencyPlugins, devDependencies) {
+  let pluginsInNodeModules = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules')], '', 'Unable to get the plugins inside node_modules', true, false);
+  let pluginsToBeInstalled = [];
+  pluginsForCurrentRepo.filter(plugin => {
+    if (plugin.packageName.startsWith('@')) {
+      let scope = plugin.packageName.split('/')[0];
+      let pluginName = plugin.packageName.split('/')[1];
+      let scopedPlugins = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules', scope)], '', 'Unable to get the plugins inside the scope inside node_modules', true, false);
+      let isPluginInstalled = scopedPlugins.includes(pluginName) ? true : false;
+      if (!isPluginInstalled) {
+        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
+      }
+    } else {
+      let isPluginInstalled = pluginsInNodeModules.includes(plugin.packageName) ? true : false;
+      if (!isPluginInstalled) {
+        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
+      }
+    }
+    if (pluginNamesOfDevDependencyPlugins.includes(plugin.packageName)) {
+      if (plugin.version !== devDependencies[plugin.packageName]) {
+        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
+      }
+    }
+  });
+  return pluginsToBeInstalled;
+}
 function getAllPlugins() {
   let serviceSpecificPlugins = [];
   const pathToCommonPluginsFile = path.join(getLibraryInstalledLocation(), commonLinterRepoName, 'common', 'pluginVersion.js');
@@ -46,6 +79,29 @@ function checkIfPluginsAreInstalled() {
     noPluginMessage: '',
     uninstalledPlugins: []
   };
+  // let pluginsIndevDependencies = {}
+  // let pluginNamesOfDevDependencyPlugins = []
+  // let arePluginsPresentIndevDependencies = false
+  // var arePluginsPresentForCurrentRepo = false
+
+  // if(existsSync(path.join(getNodeModulesPath(),'package.json'))){
+  //     let packageJsonContent = require(path.join(getNodeModulesPath(),'package.json'))
+  //     pluginsIndevDependencies = packageJsonContent.devDependencies
+
+  //     if(pluginsIndevDependencies !== undefined){
+  //         arePluginsPresentIndevDependencies = true
+  //         pluginNamesOfDevDependencyPlugins = Object.keys(pluginsIndevDependencies)
+  //     }
+  //     else if(pluginsIndevDependencies === undefined){
+  //         Logger.log(Logger.INFO_TYPE,'No devDependencies present!')
+  //     }
+  // }
+  // else{
+  //     arePluginsPresentIndevDependencies = false
+  // }
+
+  // arePluginsPresentForCurrentRepo = pluginsForCurrentRepo.length !== 0 ? true : false
+
   uninstalledPlugins = pluginsForCurrentRepo.map(plugin => {
     const {
       packageName,
@@ -58,12 +114,10 @@ function checkIfPluginsAreInstalled() {
     if (isPluginPresent && checkPluginHasProperVersion(packageName, pluginPath, version)) {
       return false;
     }
-    return {
-      packageName,
-      version
-    };
+    return `${packageName}@${version}`;
   }).filter(Boolean);
   if (uninstalledPlugins.length > 0) {
+    // uninstalledPlugins = getUnInstalledPlugins(pluginsForCurrentRepo, pluginNamesOfDevDependencyPlugins, pluginsIndevDependencies);
     plugin.noPluginMessage = '';
     plugin.uninstalledPlugins = uninstalledPlugins;
     return plugin;

package/build/utils/PluginsInstallation/installPlugins.js

@@ -6,6 +6,9 @@ const {
 const {
   writeFileSync
 } = require('fs');
+const {
+  checkIfPluginsAreInstalled
+} = require('./checkIfPluginsAreInstalled');
 const {
   executeSynchronizedCommands
 } = require('../General/executeSyncCommands');
@@ -23,32 +26,35 @@ const {
  * @function installPlugins - installs uninstalled plugins for the project
  * @returns {boolean} - indicating if plugins to be installed are installed successfully or not
  */
-
 function installPlugins(pluginsToBeInstalled) {
-  if (pluginsToBeInstalled.length === 0) {
+  // let {uninstalledPlugins : pluginsToBeInstalled} = checkIfPluginsAreInstalled()
+  if (pluginsToBeInstalled.length > 0) {
+    let packageJsonBeforePluginsInstallation = getPackageJsonContentBeforeInstallingPlugins();
+    let installCommand = `npm install --save-dev ${pluginsToBeInstalled.join(' ')}`;
+    Logger.log(Logger.INFO_TYPE, 'Installing plugins ....');
+    Logger.log(Logger.INFO_TYPE, `Install command being executed: ${installCommand}`);
+    let arePluginsInstalledSuccessfully = executeSynchronizedCommands(execSync, [installCommand, {
+      stdio: 'inherit',
+      cwd: getNodeModulesPath()
+    }], '', 'Some issue occured while installing plugins', false, true);
+    if (arePluginsInstalledSuccessfully) {
+      Logger.log(Logger.SUCCESS_TYPE, 'Plugins installation successful');
+      let isPackageJsonRestored = restorePackageJsonContent(packageJsonBeforePluginsInstallation);
+      if (isPackageJsonRestored) {
+        createVersionControlFile(pluginsToBeInstalled);
+        // return true 
+      } else {
+        Logger.log(Logger.FAILURE_TYPE, 'Unable to restore package.json content');
+        // return false
+      }
+    } else {
+      Logger.log(Logger.FAILURE_TYPE, "Unable to install plugins.Kindly retry the command");
+      // return false
+    }
+  } else {
     Logger.log(Logger.INFO_TYPE, 'Plugins are already installed');
-    return true;
-  }
-  const packageJsonBackup = getPackageJsonContentBeforeInstallingPlugins();
-  const installCommand = `npm install --save-dev ${pluginsToBeInstalled.join(' ')}`;
-  Logger.log(Logger.INFO_TYPE, 'Installing plugins...');
-  Logger.log(Logger.INFO_TYPE, `Install command being executed: ${installCommand}`);
-  const installed = executeSynchronizedCommands(execSync, [installCommand, {
-    stdio: 'inherit',
-    cwd: getNodeModulesPath()
-  }], '', 'Some issue occurred while installing plugins', false, true);
-  if (!installed) {
-    Logger.log(Logger.FAILURE_TYPE, 'Unable to install plugins. Kindly retry the command');
-    return false;
+    // return true
   }
-  Logger.log(Logger.SUCCESS_TYPE, 'Plugins installation successful');
-  const restored = restorePackageJsonContent(packageJsonBackup);
-  if (!restored) {
-    Logger.log(Logger.FAILURE_TYPE, 'Unable to restore package.json content');
-    return false;
-  }
-  createVersionControlFile(pluginsToBeInstalled);
-  return true;
 }
 
 /**
@@ -70,6 +76,53 @@ function restorePackageJsonContent(packageJsonContentBeforePluginsInstallation)
   let isPackageJsonRestored = executeSynchronizedCommands(writeFileSync, [packageJsonFilePath, JSON.stringify(packageJsonContentBeforePluginsInstallation, null, 2)], 'Package.json content restored successfully', 'Unable to restore package.json content', false, true);
   return isPackageJsonRestored;
 }
+
+// function appendInstalledPluginsToPackageJson(pluginsToBeAppendedInPackageJson){
+//     let packageJsonFilePath = `${nodeModulesPathOfProject}/package.json`
+//     let packageJsonContent = require(packageJsonFilePath)
+//     let devDependencies = packageJsonContent.devDependencies
+//     let pluginsToBeAddedInDevDependencies = {}
+
+//     executeSynchronizedCommands(process.chdir,[nodeModulesPathOfProject],'','Unable to navigate to node_modules path when trying to revert changes in package.json',false,false)
+
+//     let gitDiffOutput = executeSynchronizedCommands(execSync,['git diff --name-only'],'','Unable to execute git diff command while checking if package.json is changed',true,false).toString().trim()
+//     let isPackageJsonChanged = gitDiffOutput.includes('package.json') ? true : false
+
+//     if(isPackageJsonChanged){
+//         let packageJsonChangesRevertCommand = `git checkout "${packageJsonFilePath}"`
+//         isPackageJsonChangesRevertedSuccessfully = executeSynchronizedCommands(execSync,[packageJsonChangesRevertCommand,{stdio:'inherit'}],'Changes in package.json reverted successfully','Unable to revert the changes in package.json file',false,true)
+
+//         if(isPackageJsonChangesRevertedSuccessfully){
+//             pluginsToBeAppendedInPackageJson.map(uninstalledPlugin => {
+//                 if(uninstalledPlugin.startsWith('@')){
+//                     let indexOfAtCharacter = uninstalledPlugin.indexOf('@')
+//                     let indexOfSecondOccurenceOfAtCharacter = uninstalledPlugin.indexOf('@',indexOfAtCharacter + 1)
+//                     let unInstalledPluginName = uninstalledPlugin.slice(0,indexOfSecondOccurenceOfAtCharacter)
+//                     let unInstalledPluginVersion = uninstalledPlugin.slice(indexOfSecondOccurenceOfAtCharacter + 1)
+//                     pluginsToBeAddedInDevDependencies[unInstalledPluginName] = unInstalledPluginVersion
+//                 }
+//                 else{
+//                     pluginsToBeAddedInDevDependencies[uninstalledPlugin.split('@')[0]] = uninstalledPlugin.split('@')[1]
+//                 }
+//                 })
+//                 let updatedPluginsIndevDependencies = {
+//                     ...devDependencies,
+//                     ...pluginsToBeAddedInDevDependencies
+//                 }
+//                 packageJsonContent.devDependencies = updatedPluginsIndevDependencies
+
+//                 let modifiedPackageJson = {
+//                     ...packageJsonContent,
+//                 }
+//                 let isPluginsAddedInPackageJson = executeSynchronizedCommands(writeFileSync,[packageJsonFilePath,JSON.stringify(modifiedPackageJson,null,2)],'Newly installed plugins successfully added to package.json','Unable to append installed plugins to package.json',false,true)
+//                 return isPluginsAddedInPackageJson 
+//         }
+//         else{
+//             return true
+//         }
+//     }
+// }
+
 module.exports = {
   installPlugins
 };

package/index.js

@@ -1,4 +1,4 @@
-const { getLintConfigurationUtil } = require("./build/utils/ConfigFileUtils/getLintConfiguration");
+const { getLintConfigurationUtil } = require("./build/utils/EslintConfigFileUtils/getLintConfiguration");
 const { rulesConfig, plugins, extendPlugins } = getLintConfigurationUtil();
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/codestandard-validator",
-  "version": "0.0.6-exp-20",
+  "version": "0.0.6-exp-21",
   "description": "library to enforce code standard using eslint",
   "main": "index.js",
   "scripts": {
@@ -22,7 +22,6 @@
     "@babel/core": "7.24.7",
     "@babel/plugin-transform-runtime": "7.24.7",
     "@babel/preset-env": "7.24.7",
-    "husky": "7.0.4",
-    "stylelint": "^16.0.0"
+    "husky": "7.0.4"
   }
 }