@zohodesk/codestandard-validator 1.0.0-exp-3 → 1.0.0-exp-4

package/build/hooks/Precommit/lint.js

@@ -37,6 +37,9 @@ const {
 const {
   Logger
 } = require('../../utils/Logger/Logger');
+const {
+  default: fetchProjectIssuesViaCurl
+} = require('../../utils/General/SonarQubeUtil');
 const execAsync = promisify(exec);
 async function lintFiles(filePath) {
   const ext = path.extname(filePath);
@@ -84,7 +87,6 @@ async function runLintWorkflow(files, branch) {
   const branchDiff = {
     diffs: []
   };
-  let shouldAbort = false;
   var branchName = getBranchName();
   for (const file of files) {
     if (!getSupportedLanguage().includes(path.extname(file))) continue;
@@ -95,31 +97,31 @@ async function runLintWorkflow(files, branch) {
       diff: changeset
     };
     branchDiff.diffs.push(diff);
-    // const filteredErrors = impactBasedPrecommit
-    //   ? await filterErrorsByChangedLines(errors, branch, file)
-    //   : filterFileLevelErrors(errors);
-
-    // if (filteredErrors.length > 0) {
-    //   logErrors(file, filteredErrors);
-    //   shouldAbort ||= shouldWarningsAbortCommit || !isOnlyWarnings(filteredErrors);
-    // }
   }
   const diffPath = path.resolve(getNodeModulesPath(), 'diffBranch.json');
   fs.writeFileSync(diffPath, JSON.stringify(branchDiff));
   const cliobj = {
     env: 'ci',
-    cmdExecuted: 'dev-ci'
+    cmdExecuted: 'precommit'
   };
   const execute = new Execution(EsLint, SonarQube, cliobj);
   await execute.executeLintHandler().finally(async () => {
     await execute.executeMetricHandler();
+    /**
+     *         global.analytics.totalIssues = global.analytics.totalIssues + 1;
+        global.analytics.status = "FAILURE";
+        global.analytics.message = 'Issues are detected, please review and resolve the errors'
+     */
+    const {
+      issues,
+      hasIssue,
+      totalIssues
+    } = fetchProjectIssuesViaCurl("projectName");
   });
   Logger.log(Logger.INFO_TYPE, global.analytics);
   return global.analytics.status == 'FAILURE' ? true : false;
 }
 module.exports = {
   runLintWorkflow,
-  lintFiles,
-  findEslintErrors,
-  findStyleLintErrors
+  lintFiles
 };

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

@@ -0,0 +1,369 @@
+"use strict";
+
+const {
+  exec
+} = 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
+} = 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 (String(path.extname(filePath))) {
+    case '.js':
+    case '.ts':
+    case '.tsx':
+    case '.jsx':
+    case '.properties':
+      {
+        return await findEslintErrors(filePath);
+      }
+    case '.css':
+    case '.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.js');
+  const absolutePath = path.join(getRootDirectory(), filePath);
+  try {
+    return new Promise((resolve, reject) => {
+      exec(`npx stylelint ${absolutePath} --config ${configFilePath}`, {
+        cwd: getNodeModulesPath()
+      }, (error, stderr, stdout) => {
+        if (stdout) {
+          resolve(stdout.trim().split('\n'));
+        }
+        // if(stderr){
+        //     resolve(stderr.trim().split('\n'))
+        // }
+        else if (error) {
+          Logger.log(Logger.FAILURE_TYPE, error);
+          reject("Error executing stylelint 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}
+ */
+
+async function preCommitHook_default() {
+  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) {
+          const {
+            JsFiles: staged_filesJS,
+            CssFiles
+          } = filterFiles(staged_files, eslintConfigFiles, true);
+
+          // 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)
+          // }
+
+          // CssFiles not Enabled For while 
+          areFilesStaged = true;
+          var stagedFiles = [...staged_filesJS];
+          for (let file in stagedFiles) {
+            let currentFileName = stagedFiles[file];
+            let changedLinesArray = [];
+            let eslintErrorsInChangedLines = [];
+            let isOnlyEslintWarningsPresentInFile = false;
+            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) {
+                      //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('@@'));
+                      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 < 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
+
+                        let eslintErrorLineNumber = errorsInFile[error].trim().split(' ')[0].split(':')[0];
+                        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 lint 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 linter 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 lint 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);
+    }
+  }
+}
+preCommitHook_default();

package/build/hooks/hook.js

@@ -4,23 +4,23 @@ const {
   getLastCommitHash,
   getStoredCommitHash,
   updateJsonFile
-} = require("../utils/General/getGeneralInfo");
+} = require('../utils/General/getGeneralInfo');
 const {
   executeMethodsThatReturnBooleanValue
-} = require("../utils/General/wrapperFunctionToExecuteAFunction");
+} = require('../utils/General/wrapperFunctionToExecuteAFunction');
 const {
   cloneViaCdt
-} = require("../utils/CloneCommonLinterRepo/cloneViaCdt");
+} = require('../utils/CloneCommonLinterRepo/cloneViaCdt');
 const {
   getPluginsToInstall
-} = require("../utils/PluginsInstallation/checkIfPluginsAreInstalled");
+} = require('../utils/PluginsInstallation/checkIfPluginsAreInstalled');
 const {
   installPlugins
-} = require("../utils/PluginsInstallation/installPlugins");
-const path = require("path");
+} = require('../utils/PluginsInstallation/installPlugins');
+const path = require('path');
 const {
   Logger
-} = require("../utils/Logger/Logger");
+} = require('../utils/Logger/Logger');
 async function hooks() {
   var jsonFilePath = path.join(__dirname, '..', '..', 'jsonUtils', 'fsUtils.json');
   if (!(getLastCommitHash() == getStoredCommitHash())) {
@@ -29,12 +29,17 @@ async function hooks() {
       return data;
     });
     Logger.log(Logger.INFO_TYPE, `Some rules and plugins are being fetched from a remote source and installed...`);
-    await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
+    await executeMethodsThatReturnBooleanValue('Make sure zgit.csez.zohocorpin.com is accessible', cloneViaCdt, null);
     const {
       uninstalledPlugins
     } = getPluginsToInstall();
-    await executeMethodsThatReturnBooleanValue("Some issue occurred in installing plugins", installPlugins, uninstalledPlugins);
+    await executeMethodsThatReturnBooleanValue('Some issue occurred in installing plugins', installPlugins, uninstalledPlugins);
+  }
+  console.log(process.env);
+  if (process.env.defaultprecommit) {
+    require('./Precommit/pre-commit-default');
+  } else {
+    require('./Precommit/commit');
   }
-  require('./Precommit/commit');
 }
 hooks();

package/build/utils/General/SonarQubeUtil.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Logger = require("../Logger/Logger");
+var _getGeneralInfo = require("./getGeneralInfo");
+var _child_process = require("child_process");
+/**
+ * Constructs a URL for searching issues in SonarQube.
+ *
+ * @param {string} componentKey - The key of the component to search issues for.
+ * @returns {string} The fully constructed URL for the SonarQube issues search API.
+ */
+
+function buildIssuesSearchUrl(componentKey) {
+  const {
+    metricServerHost
+  } = (0, _getGeneralInfo.getConfigurationPrecommit)();
+  const base = `${"https://client-linters.zdesk.csez.zohocorpin.com" || metricServerHost}/api/issues/search`;
+  const params = new URLSearchParams({
+    componentKeys: componentKey,
+    s: 'FILE_LINE',
+    resolved: 'false',
+    ps: '100',
+    facets: 'severities,types',
+    additionalFields: '_all',
+    timeZone: 'Asia/Calcutta'
+  });
+  return `${base}?${params.toString()}`;
+}
+
+/**
+ * Extract minimal issue info from SonarQube issues JSON.
+ */
+function extractIssues(json) {
+  var hasIssue = false;
+  var totalIssues = json.issues.length;
+  if (!json || !Array.isArray(json.issues)) return [];
+  return {
+    issues: json.issues.map(i => {
+      if (i.severity == 'MAJOR') {
+        hasIssue = true;
+      }
+      return {
+        key: i.key,
+        component: i.component,
+        severity: i.severity,
+        type: i.type,
+        message: i.message,
+        line: i.line,
+        rule: i.rule,
+        status: i.status
+      };
+    }),
+    hasIssue,
+    totalIssues
+  };
+}
+
+/**
+ * Fetches project issues for a given component key using a cURL command.
+ *
+ * This function constructs a URL to search for issues, decrypts an API token,
+ * and executes a cURL command to retrieve the issues in JSON format. It then
+ * extracts and returns the issues along with the raw JSON response.
+ *
+ * @param {string} componentKey - The key of the component for which issues are to be fetched.
+ * @returns {Object} An object containing:
+ *   - {Object|null} raw: The raw JSON response from the API, or null if an error occurred.
+ *   - {Array} issues: An array of extracted issues, or an empty array if an error occurred.
+ */
+
+function fetchProjectIssuesViaCurl(componentKey) {
+  _Logger.Logger.log(_Logger.Logger.INFO_TYPE, `\n Fetching issues (curl) for component: ${componentKey}`);
+  const url = buildIssuesSearchUrl(componentKey);
+  try {
+    const token = 'sqa_1f6675c05f63c4784dc741ce751efa0066d2693c' || decrypt(getAPIToken(), process.env.DECRYPT_TOKEN);
+    const command = `curl --tlsv1.2 -s -u "${token}:" "${url}"`;
+    console.log("command", command);
+    const output = (0, _child_process.execSync)(command).toString();
+    const json = JSON.parse(output);
+    const {
+      issues,
+      hasIssue,
+      totalIssues
+    } = extractIssues(json);
+    _Logger.Logger.log(_Logger.Logger.INFO_TYPE, `Retrieved ${issues.length} issues.`);
+    return {
+      raw: json,
+      issues,
+      hasIssue,
+      totalIssues
+    };
+  } catch (err) {
+    _Logger.Logger.log(_Logger.Logger.FAILURE_TYPE, 'Issue fetching project issues (curl)');
+    _Logger.Logger.log(_Logger.Logger.FAILURE_TYPE, err);
+    return {
+      raw: null,
+      issues: [],
+      hasIssue: true,
+      totalIssues: 0
+    };
+  }
+}
+console.log(fetchProjectIssuesViaCurl('zohogc_client_master_rajasekar.hm_Dev-report'));
+var _default = exports.default = fetchProjectIssuesViaCurl;

package/build/utils/PluginsInstallation/installPlugins.js

@@ -15,6 +15,7 @@ const {
 const {
   getNodeModulesPath
 } = require('../General/getNodeModulesPath');
+const path = require('path');
 
 /**
  * @function installPlugins - installs uninstalled plugins for the project
@@ -32,15 +33,7 @@ function installPlugins(pluginsToBeInstalled) {
     }], '', '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
-      // }
+      return restorePackageJsonContent(packageJsonBeforePluginsInstallation);
     } else {
       Logger.log(Logger.FAILURE_TYPE, "Unable to install plugins. Kindly retry the command");
       return false;
@@ -66,7 +59,7 @@ function getPackageJsonContentBeforeInstallingPlugins() {
  * @returns {Boolean} - indicating the success or failure of restoring package.json content
  */
 function restorePackageJsonContent(packageJsonContentBeforePluginsInstallation) {
-  let packageJsonFilePath = `${getNodeModulesPath()}/package.json`;
+  let packageJsonFilePath = path.join(getNodeModulesPath(), 'package.json');
   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;
 }

package/index.js

@@ -6,3 +6,55 @@ module.exports = {
   plugins,
   extendPlugins
 };
+
+
+
+function config() {
+  return {
+    addConfig(conf){
+      return conf
+    },
+    addRule(){
+
+    }
+  };
+}
+
+
+
+const rule =  {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow the use of 'debugger' statements",
+      category: "Possible Errors",
+      recommended: true,
+    },
+    schema: [], // No options for this rule
+    messages: {
+      noDebugger: "Unexpected 'debugger' statement.",
+    },
+  },
+  create(){
+    return {
+      DebuggerStatement(node) {
+        context.report({
+          node,
+          messageId: "noDebugger",
+        });
+      },
+    };
+  }
+};
+
+
+const { addConfig, addRule } = config()
+
+addRule([{name:"dummyrule",conf:rule}])
+
+addConfig([{
+  files: ["config/*.js"], 
+  rules: {
+    "no-console": "off",
+  },
+}])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/codestandard-validator",
-  "version": "1.0.0-exp-3",
+  "version": "1.0.0-exp-4",
   "description": "library to enforce code standard using eslint",
   "main": "index.js",
   "scripts": {
@@ -15,10 +15,10 @@
   },
   "type": "commonjs",
   "dependencies": {
-    "@zohodesk/codestandard-analytics":"1.0.2-exp-3",
+    "@zohodesk/codestandard-analytics": "1.0.2-exp-3",
     "@zohodesk-private/client_deployment_tool": "0.0.5",
     "eslint": "8.26.0",
-    "stylelint":"16.23.0"
+    "stylelint": "16.23.0"
   },
   "devDependencies": {
     "@babel/core": "7.24.7",