@zohodesk/codestandard-validator 1.2.4-exp-1 → 1.2.4-exp-2

package/build/ai/run-review.js

@@ -13,7 +13,7 @@
 
 // const PROMPT_FOLDER = path.resolve(__dirname, 'prompts');
 
-// const REVIEW_FOLDER = '/Users/raja-17710/deskApp/linter_tools/codestandard-validator/src/hooks';
+// const REVIEW_FOLDER = '/Users/raja-17710/deskApp/linter_tools/codestandard-validator/src/mutation';
 
 // const FOLDER_EXTENSIONS = ['.js', '.ts'];
 

package/build/chunk/chunk_Restriction.js

@@ -12,7 +12,16 @@ const {
 } = require('../utils/GitActions/gitActions');
 const Logger = console;
 const path = require('path');
-const gitEndPoint = 'https://zgit.csez.zohocorpin.com';
+const {
+  getConfigPath
+} = require('../../build/utils/General/getGeneralInfo');
+const {
+  getConfigPathExecute
+} = require('../utils/General/Config');
+const {
+  gitEndPoint: _gitEndPoint
+} = getConfigPath(getConfigPathExecute());
+const gitEndPoint = _gitEndPoint || 'https://zgit.csez.zohocorpin.com';
 const compareBranch = ((_process = process) === null || _process === void 0 || (_process = _process.env) === null || _process === void 0 ? void 0 : _process.CHUNK_BRANCH) || 'release';
 const configPath = path.resolve(process.cwd(), 'lint.config.js');
 function getGitProjectId() {
@@ -168,7 +177,7 @@ if (shouldEnable) {
   const GREEN = '\x1b[32m';
   const RESET = '\x1b[0m';
   (async function () {
-    Logger.log(`******************************** Experimental Phase Calculation Chunk Size ********************************`);
+    Logger.log(`****************************** Calculation Chunk Size *******************************`);
     if (!(globalThis !== null && globalThis !== void 0 && globalThis.chunkSize)) {
       globalThis.chunkSize = {
         $modifieldLines: 0,

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

@@ -58,7 +58,7 @@ async function isMergeCommit() {
 
 async function getStagedFiles() {
   return new Promise((resolve, reject) => {
-    exec("git diff --staged --name-only", (error, stderr, stdout) => {
+    exec('git diff --staged --name-only', (error, stderr, stdout) => {
       if (error) {
         if (error != null) reject("Couldn't fetch staged files");
       } else if (stderr) {
@@ -73,7 +73,7 @@ async function getStagedFiles() {
 /**
  * @function {filterDeltedFileFromStagedFiles} - filter deleted staged files
  * @param {Array<string>} files - staged files
- * @returns 
+ * @returns
  */
 function filterDeltedFileFromStagedFiles(files) {
   return files.filter(file => {
@@ -109,7 +109,7 @@ async function lintFiles(filePath) {
 /**
  * @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 
+ * @returns {Array<string>} -  array of command line report as a string
  */
 
 function findEslintErrors(file) {
@@ -126,10 +126,15 @@ function findEslintErrors(file) {
             resolve(stderr.trim().split('\n'));
           } else if (error) {
             Logger.log(Logger.FAILURE_TYPE, error);
-            reject("Error executing eslint command");
+            reject('Error executing eslint command');
           } else {
             resolve([]);
           }
+        }, {
+          env: {
+            ...process.env,
+            CHUNK_SIZE: (globalThis === null || globalThis === void 0 ? void 0 : globalThis.chunkSize) ?? ''
+          }
         });
       });
     } else {
@@ -141,8 +146,8 @@ function findEslintErrors(file) {
 }
 
 /**
- * 
- * @param {*} params 
+ *
+ * @param {*} params
  */
 function findStyleLintErrors(filePath) {
   const configFilePath = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
@@ -156,7 +161,7 @@ function findStyleLintErrors(filePath) {
           resolve(stdout.trim().split('\n'));
         } else if (error) {
           Logger.log(Logger.FAILURE_TYPE, error);
-          reject("Error executing stylelint command");
+          reject('Error executing stylelint command');
         } else {
           resolve([]);
         }
@@ -172,7 +177,7 @@ function findStyleLintErrors(filePath) {
  * @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 
+ * @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()} ${path.resolve(getRootDirectory(), file)}`;
@@ -194,13 +199,115 @@ async function calculateGitDiffForFile(branch_name, file) {
 function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
   let severityOfEachErrorInFile = [];
   eslintErrorsPresent.map(error => {
-    let partsInString = error.split(" ");
+    let partsInString = error.split(' ');
     let severityOfError = partsInString.find(word => word === 'error' || word === 'warning' || word === '✖');
     severityOfEachErrorInFile.push(severityOfError);
   });
   return !(severityOfEachErrorInFile.includes('✖') || severityOfEachErrorInFile.includes('error'));
 }
 
+/**
+ * Parse git diff hunk headers into changed line ranges.
+ * @param {string[]} diffLines - raw git diff output lines
+ * @returns {Array<{start: number, end: number}>}
+ */
+function getChangedLineRanges(diffLines) {
+  return diffLines.filter(line => line.startsWith('@@')).map(line => {
+    const [startStr, countStr] = line.split(' ')[2].split(',');
+    const start = parseInt(startStr, 10);
+    const end = countStr !== undefined ? start + parseInt(countStr, 10) - 1 : start;
+    return {
+      start,
+      end
+    };
+  });
+}
+
+/**
+ * Extract only error/warning lines from eslint output (strip header & summary).
+ * @param {string[]} rawOutput
+ * @returns {string[]}
+ */
+function extractLintErrors(rawOutput) {
+  if (!rawOutput || rawOutput.length <= 2) return [];
+  return rawOutput.slice(1, rawOutput.length - 2);
+}
+
+/**
+ * Filter lint errors to those on changed lines or matching mandatory rules.
+ * @param {string[]} lintErrors - extracted error lines
+ * @param {Array<{start: number, end: number}>} ranges - changed line ranges
+ * @returns {string[]}
+ */
+function filterErrorsByChangedLines(lintErrors, ranges) {
+  const result = new Set();
+  for (const errorLine of lintErrors) {
+    const lineNum = parseInt(errorLine.trim().split(' ')[0].split(':')[0], 10);
+    if (MandatoryListRules.some(ruleId => errorLine.trim().includes(ruleId))) {
+      result.add(errorLine);
+      continue;
+    }
+    for (const {
+      start,
+      end
+    } of ranges) {
+      if (lineNum >= start && lineNum <= end) {
+        result.add(errorLine);
+        break;
+      }
+    }
+  }
+  return Array.from(result);
+}
+
+/**
+ * Determine whether errors should abort the commit.
+ * @param {string[]} errors
+ * @returns {boolean}
+ */
+function shouldErrorsAbortCommit(errors) {
+  if (errors.length === 0) return false;
+  if (shouldWarningsAbortCommit) return true;
+  return !isOnlyWarningsPresentInFile(errors);
+}
+
+/**
+ * Log lint errors for a file.
+ * @param {string} fileName
+ * @param {string[]} errors
+ */
+function logFileErrors(fileName, errors) {
+  Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${fileName}\x1b[0m`);
+  for (const error of errors) {
+    Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${error.trimEnd()}\x1b[0m`);
+  }
+}
+
+/**
+ * Process a single staged file: lint it, optionally filter by changed lines, and return whether to abort.
+ * @param {string} file - relative file path
+ * @param {string} currentBranch
+ * @returns {Promise<boolean>} - true if this file should cause an abort
+ */
+async function processFile(file, currentBranch) {
+  if (!getSupportedLanguage().includes(path.extname(file))) return false;
+  const rawErrors = await lintFiles(file);
+  if (!rawErrors || !file || typeof file !== 'string') return false;
+  const lintErrors = extractLintErrors(rawErrors);
+  if (lintErrors.length === 0) return false;
+  let relevantErrors;
+  if (impactBasedPrecommit) {
+    const diffLines = await calculateGitDiffForFile(currentBranch, file);
+    const ranges = getChangedLineRanges(diffLines);
+    relevantErrors = filterErrorsByChangedLines(lintErrors, ranges);
+  } else {
+    relevantErrors = lintErrors;
+  }
+  if (relevantErrors.length === 0) return false;
+  logFileErrors(file, relevantErrors);
+  return shouldErrorsAbortCommit(relevantErrors);
+}
+
 /**
  * @function {preCommitHook} - method execute pre commit hook
  * @returns {void}
@@ -209,142 +316,53 @@ function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
 async function preCommitHook_default() {
   Logger.log(Logger.INFO_TYPE, '\n Executing pre commit hook...');
   Logger.log(Logger.INFO_TYPE, `working dir  : ${process.cwd()}`);
+
+  // Skip merge commits
   try {
-    let isMerge = await isMergeCommit();
+    await isMergeCommit();
     Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
     process.exit(0);
-  } catch (error) {
-    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");
-    }
+  } catch {
+    // Not a merge commit — continue
+  }
+  let currentBranch = '';
+  try {
+    currentBranch = await getBranchName();
+  } catch {
+    Logger.log(Logger.INFO_TYPE, 'Error fetching current branch');
+  }
+  let stagedFiles = [];
+  try {
+    stagedFiles = await getStagedFiles();
+  } catch {
+    Logger.log(Logger.INFO_TYPE, 'Error executing pre commit hook');
+    return;
+  }
+  if (!stagedFiles || stagedFiles.length === 0) {
+    Logger.log(Logger.INFO_TYPE, 'No files have been staged. Stage your files before committing');
+    return;
+  }
+  const {
+    JsFiles,
+    CssFiles
+  } = filterFiles(stagedFiles, ['.eslintrc.js'], true);
+  const filesToLint = [...JsFiles, ...CssFiles];
+  let shouldAbortCommit = false;
+  for (const file of filesToLint) {
     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, ...CssFiles];
-        for (let file in stagedFiles) {
-          let currentFileName = stagedFiles[file];
-          let changedLinesArray = [];
-          let eslintErrorsInChangedLines = new Set();
-          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];
-                      if (MandatoryListRules.some(ruleId => errorsInFile[error].trim().includes(ruleId))) {
-                        eslintErrorsInChangedLines.add(errorsInFile[error]);
-                      }
-                      for (let lineNumber in changedLinesStartArray) {
-                        if (eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && eslintErrorLineNumber <= changedLinesEndArray[lineNumber]) {
-                          eslintErrorsInChangedLines.add(errorsInFile[error]);
-                        }
-                      }
-                    }
-                    if (eslintErrorsInChangedLines.size > 0) {
-                      isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(Array.from(eslintErrorsInChangedLines));
-                      Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
-                      for (let eslintError of Array.from(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);
+      const shouldAbort = await processFile(file, currentBranch);
+      if (shouldAbort) shouldAbortCommit = true;
+    } catch (err) {
+      Logger.log(Logger.FAILURE_TYPE, err);
+      Logger.log(Logger.FAILURE_TYPE, 'Error in executing lint command');
     }
   }
+  if (shouldAbortCommit) {
+    Logger.log(Logger.FAILURE_TYPE, 'There are linter errors/warnings present. So commit is aborted.');
+    process.exit(1);
+  } else {
+    Logger.log(Logger.SUCCESS_TYPE, 'Commit Successful');
+    process.exit(0);
+  }
 }
 preCommitHook_default();

package/build/mutation/branchDiff.js

@@ -0,0 +1,178 @@
+"use strict";
+
+const {
+  execSync
+} = require('child_process');
+const path = require('path');
+class BranchDiff {
+  constructor(options = {}) {
+    this._cwd = options.cwd || process.cwd();
+    this._api = options.api || null;
+    this._patToken = options.patToken || null;
+    this._sourceExtensions = options.sourceExtensions || ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+    this._testPattern = options.testPattern || /\.(test)\.(js|ts|jsx|tsx|mjs|cjs)$/;
+  }
+  _getCurrentBranch() {
+    try {
+      return execSync('git rev-parse --abbrev-ref HEAD', {
+        cwd: this._cwd,
+        encoding: 'utf-8'
+      }).trim();
+    } catch (err) {
+      throw new Error(`Failed to get current branch: ${err.message}`);
+    }
+  }
+  _fetchBranch(branch) {
+    try {
+      execSync(`git fetch origin ${branch}`, {
+        cwd: this._cwd,
+        encoding: 'utf-8',
+        stdio: 'pipe'
+      });
+    } catch (err) {
+      // Branch might already be available locally
+    }
+  }
+  _resolveBranchRef(branch) {
+    // Check if the ref exists locally
+    const candidates = [branch, `origin/${branch}`];
+    for (const ref of candidates) {
+      try {
+        execSync(`git rev-parse --verify ${ref}`, {
+          cwd: this._cwd,
+          encoding: 'utf-8',
+          stdio: 'pipe'
+        });
+        return ref;
+      } catch {
+        // try next
+      }
+    }
+    throw new Error(`Branch '${branch}' not found locally or as 'origin/${branch}'. ` + `Run 'git fetch origin ${branch}' or check the branch name.`);
+  }
+  _getDiffFiles(targetBranch) {
+    const currentBranch = this._getCurrentBranch();
+    this._fetchBranch(targetBranch);
+    const resolvedRef = this._resolveBranchRef(targetBranch);
+    let diffRef;
+    try {
+      const mergeBase = execSync(`git merge-base ${resolvedRef} ${currentBranch}`, {
+        cwd: this._cwd,
+        encoding: 'utf-8'
+      }).trim();
+      diffRef = mergeBase;
+    } catch {
+      diffRef = resolvedRef;
+    }
+    try {
+      const output = execSync(`git diff --name-only --diff-filter=ACMR ${diffRef}`, {
+        cwd: this._cwd,
+        encoding: 'utf-8'
+      });
+      return output.split('\n').map(f => f.trim()).filter(f => f.length > 0);
+    } catch (err) {
+      throw new Error(`Failed to get diff files against branch '${targetBranch}': ${err.message}`);
+    }
+  }
+  _getDiffFilesFromApi(targetBranch) {
+    if (!this._api || !this._patToken) {
+      throw new Error('API and PAT token are required for API-based diff');
+    }
+    // Placeholder for API-based diff (e.g., Azure DevOps, GitHub, etc.)
+    // Consumers can pass in their own api object that implements `getChangedFiles(targetBranch, patToken)`
+    if (typeof this._api.getChangedFiles === 'function') {
+      return this._api.getChangedFiles(targetBranch, this._patToken);
+    }
+    throw new Error('API object must implement getChangedFiles(targetBranch, patToken)');
+  }
+
+  /**
+   * Fetches branch diff from GitLab compare API via HTTPS
+   * @param {string} hostname - GitLab host (e.g. 'gitlab.example.com')
+   * @param {string} branch - Target branch to compare against
+   * @returns {Promise<string[]>} - Array of changed file paths
+   */
+  _fetchBranchDiffFromApi(hostname, branch, projectId) {
+    const currentBranch = this._getCurrentBranch();
+    const patToken = this._patToken || process.env.ZGIT_TOKEN;
+    if (!patToken) {
+      return reject(new Error('PAT token is required. Set it via options.patToken or ZGIT_TOKEN env var'));
+    }
+    if (!projectId) {
+      return reject(new Error('GitLab projectId is required for API-based diff'));
+    }
+    const createBranchDiffChunk = (resolve, reject) => {
+      // code duplicate need find solution
+      var command;
+      const endPoint = `${hostname}/api/v4/projects/${encodeURIComponent(projectId)}/repository/compare?from=${branch}&to=${currentBranch}`;
+      try {
+        command = `curl --header "PRIVATE-TOKEN:${patToken}" "${endPoint}"`;
+        return resolve(parserReleaseDiffRemoteAPI(JSON.parse(execSync(command, {
+          cwd: this._cwd
+        }))));
+      } catch (error) {
+        Logger.log(error);
+        Logger.log(`\n INFO : If you are using a VPN and encounter an SSL certification issue, ensure that the proxy is enabled for SSH and shell connections.`);
+        Logger.log(`\n Make sure that you have access to this repository`);
+        reject(error);
+      }
+    };
+    function parserReleaseDiffRemoteAPI(rawresponse) {
+      var formatted = [];
+      if (rawresponse !== null && rawresponse !== void 0 && rawresponse.diffs) {
+        formatted = rawresponse.diffs.map(changeset => {
+          return changeset === null || changeset === void 0 ? void 0 : changeset.new_path;
+        }).filter(Boolean);
+      }
+      return formatted;
+    }
+    return new Promise((resolve, reject) => {
+      return createBranchDiffChunk(resolve, reject);
+    });
+  }
+  async getStagedFiles() {
+    try {
+      const stdout = await execSync("git diff --staged --name-only").toString();
+      const files = stdout.trim().split("\n").filter(Boolean);
+      return files;
+    } catch (error) {
+      console.log(error);
+      throw new Error("Couldn't fetch staged files");
+    }
+  }
+  async getChangedFiles(targetBranch, options = {}) {
+    let allFiles;
+    if (options.useApi && options.hostname && options.projectId) {
+      allFiles = await this._fetchBranchDiffFromApi(options.hostname, targetBranch, options.projectId).concat(await this.getStagedFiles());
+    } else {
+      allFiles = this._getDiffFiles(targetBranch);
+    }
+    return this._categorizeFiles(allFiles);
+  }
+  _isSourceFile(filePath) {
+    const ext = path.extname(filePath);
+    if (!this._sourceExtensions.includes(ext)) {
+      return false;
+    }
+    return !this._testPattern.test(filePath);
+  }
+  _isTestFile(filePath) {
+    return this._testPattern.test(filePath);
+  }
+  _categorizeFiles(files) {
+    const sourceFiles = [];
+    const testFiles = [];
+    for (const file of files) {
+      if (this._isTestFile(file)) {
+        testFiles.push(file);
+      } else if (this._isSourceFile(file)) {
+        sourceFiles.push(file);
+      }
+    }
+    return {
+      sourceFiles,
+      testFiles
+    };
+  }
+}
+module.exports = BranchDiff;