test-pmd-rule 1.0.2 → 1.1.0

package/dist/test-pmd-rule.js

@@ -7,7 +7,7 @@ import { argv } from "process";
 import { cpus } from "os";
 
 // src/tester/RuleTester.ts
-import { readFileSync as readFileSync3, existsSync } from "fs";
+import { readFileSync as readFileSync4, existsSync } from "fs";
 import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
 
 // src/xpath/extractXPath.ts
@@ -63,8 +63,8 @@ import { readFileSync as readFileSync2 } from "fs";
 
 // src/xpath/extractors/extractNodeTypes.ts
 function extractNodeTypes(xpath) {
-  const MIN_STRING_LENGTH5 = 0;
-  if (xpath.length === MIN_STRING_LENGTH5) return [];
+  const MIN_STRING_LENGTH8 = 0;
+  if (xpath.length === MIN_STRING_LENGTH8) return [];
   const nodeTypes = /* @__PURE__ */ new Set();
   const nodeTypeMatches1 = xpath.matchAll(
     /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)([A-Z][a-zA-Z]*(?:Statement|Expression|Declaration|Node|Block))(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
@@ -152,8 +152,8 @@ function extractAttributes(xpath) {
 
 // src/xpath/extractors/extractConditionals.ts
 function extractConditionals(xpath) {
-  const MIN_STRING_LENGTH5 = 0;
-  if (xpath.length === MIN_STRING_LENGTH5) return [];
+  const MIN_STRING_LENGTH8 = 0;
+  if (xpath.length === MIN_STRING_LENGTH8) return [];
   const conditionals = [];
   const MATCH_INDEX3 = 1;
   const notMatches = xpath.matchAll(/not\s*\(([^)]+)\)/g);
@@ -1022,6 +1022,34 @@ import tmp from "tmp";
 var EMPTY_LENGTH = 0;
 var FIRST_CAPTURE_GROUP_INDEX = 1;
 var SECOND_CAPTURE_GROUP_INDEX = 2;
+var TAB_CHAR = "	";
+var SPACE_CHAR = " ";
+var DEFAULT_INDENT = "    ";
+var FIRST_ELEMENT_INDEX2 = 0;
+function removeInlineMarkers(line) {
+  if (line.includes("// \u274C")) {
+    const splitResult = line.split("// \u274C");
+    const codeLine = splitResult[FIRST_ELEMENT_INDEX2];
+    return codeLine.replace(/\s+$/, "");
+  }
+  if (line.includes("// \u2705")) {
+    const splitResult = line.split("// \u2705");
+    const codeLine = splitResult[FIRST_ELEMENT_INDEX2];
+    return codeLine.replace(/\s+$/, "");
+  }
+  return line;
+}
+function formatMethodDeclarationIndent(methodDecl) {
+  const startsWithTab = methodDecl.startsWith(TAB_CHAR);
+  if (startsWithTab) {
+    return methodDecl;
+  }
+  const startsWithSpace = methodDecl.startsWith(SPACE_CHAR);
+  if (startsWithSpace) {
+    return methodDecl;
+  }
+  return `${DEFAULT_INDENT}${methodDecl}`;
+}
 function inferReturnType(code, methodName) {
   if (new RegExp(`\\b${methodName}\\s*\\(\\s*\\)\\s*[><=!]+\\s*\\d+`).test(
     code
@@ -1256,8 +1284,15 @@ function createTestFile({
     const extractedCode = [];
     let insideClass = false;
     let classBraceDepth = ZERO_BRACE_DEPTH;
+    const INITIAL_BRACE_DEPTH = 1;
+    let methodBraceDepth = ZERO_BRACE_DEPTH;
     let currentMode = null;
-    for (const line of exampleLines) {
+    let insideMethod = false;
+    let methodDeclaration = null;
+    let methodDeclarationOriginal = null;
+    let hasIncludedMethodContent = false;
+    for (let lineIndex = 0; lineIndex < exampleLines.length; lineIndex++) {
+      const line = exampleLines[lineIndex];
       const trimmed = line.trim();
       if (trimmed.includes("// \u274C")) {
         currentMode = "violation";
@@ -1270,7 +1305,6 @@ function createTestFile({
       }
       const shouldInclude = !trimmed.startsWith("//") && trimmed.length > EMPTY_LENGTH && (includeViolations && currentMode === "violation" || includeValids && currentMode === "valid");
       if (trimmed.startsWith("public class ") || trimmed.startsWith("class ") || trimmed.startsWith("private class ")) {
-        const INITIAL_BRACE_DEPTH = 1;
         const CLASS_PREFIX_GROUP_INDEX = 1;
         if (classBraceDepth === ZERO_BRACE_DEPTH) {
           const classRegex = /^(public\s+|private\s+)?class\s+(\w+)/;
@@ -1290,33 +1324,64 @@ function createTestFile({
         const closeBracesMatch = line.match(/}/g);
         const openBraces = openBracesMatch ? openBracesMatch.length : ZERO_BRACE_DEPTH;
         const closeBraces = closeBracesMatch ? closeBracesMatch.length : ZERO_BRACE_DEPTH;
+        const prevClassBraceDepth = classBraceDepth;
         classBraceDepth += openBraces - closeBraces;
+        const methodRegex = /\w+\s*\(/;
+        const methodMatch = methodRegex.exec(trimmed);
+        const hasMethodPattern = methodMatch !== null;
+        const isMethodDeclaration = prevClassBraceDepth === INITIAL_BRACE_DEPTH && classBraceDepth > INITIAL_BRACE_DEPTH && !trimmed.startsWith("{") && trimmed.includes("{") && (trimmed.includes("void") || trimmed.includes("(") || hasMethodPattern);
+        if (isMethodDeclaration) {
+          insideMethod = true;
+          methodBraceDepth = classBraceDepth - INITIAL_BRACE_DEPTH;
+          methodDeclaration = trimmed;
+          methodDeclarationOriginal = line;
+          hasIncludedMethodContent = false;
+        }
+        if (insideMethod) {
+          methodBraceDepth += openBraces - closeBraces;
+          if (methodBraceDepth <= ZERO_BRACE_DEPTH) {
+            insideMethod = false;
+            methodDeclaration = null;
+            methodDeclarationOriginal = null;
+            hasIncludedMethodContent = false;
+          }
+        }
         if (shouldInclude || trimmed === "{" || trimmed === "}") {
-          let codeLine = line;
-          const FIRST_ELEMENT_INDEX2 = 0;
-          if (line.includes("// \u274C")) {
-            const splitResult = line.split("// \u274C");
-            codeLine = splitResult[FIRST_ELEMENT_INDEX2].trim();
-          } else if (line.includes("// \u2705")) {
-            const splitResult = line.split("// \u2705");
-            codeLine = splitResult[FIRST_ELEMENT_INDEX2].trim();
+          const hasMethodDeclaration = methodDeclaration !== null && methodDeclarationOriginal !== null;
+          const markerRegex = /\s*\/\/\s*[❌✅].*$/;
+          const trimmedWithoutMarker = trimmed.replace(markerRegex, "").trim();
+          const isMethodDeclarationLine = insideMethod && hasMethodDeclaration && (trimmed === methodDeclaration || trimmedWithoutMarker === methodDeclaration);
+          if (shouldInclude && insideMethod && hasMethodDeclaration && !hasIncludedMethodContent) {
+            if (isMethodDeclarationLine) {
+              const codeLine = removeInlineMarkers(line);
+              extractedCode.push(codeLine);
+              hasIncludedMethodContent = true;
+            } else {
+              const methodDeclOriginal = methodDeclarationOriginal;
+              const methodDeclWithIndent = formatMethodDeclarationIndent(
+                methodDeclOriginal
+              );
+              extractedCode.push(methodDeclWithIndent);
+              const codeLine = removeInlineMarkers(line);
+              extractedCode.push(codeLine);
+              hasIncludedMethodContent = true;
+            }
+          } else if (shouldInclude && !isMethodDeclarationLine) {
+            const codeLine = removeInlineMarkers(line);
+            extractedCode.push(codeLine);
+          } else {
+            extractedCode.push(line);
           }
-          extractedCode.push(codeLine);
         }
         if (classBraceDepth <= ZERO_BRACE_DEPTH) {
           insideClass = false;
           classBraceDepth = ZERO_BRACE_DEPTH;
+          insideMethod = false;
+          methodDeclaration = null;
+          methodDeclarationOriginal = null;
         }
       } else if (shouldInclude) {
-        let codeLine = line;
-        const FIRST_ELEMENT_INDEX2 = 0;
-        if (line.includes("// \u274C")) {
-          const splitResult = line.split("// \u274C");
-          codeLine = splitResult[FIRST_ELEMENT_INDEX2].trim();
-        } else if (line.includes("// \u2705")) {
-          const splitResult = line.split("// \u2705");
-          codeLine = splitResult[FIRST_ELEMENT_INDEX2].trim();
-        }
+        const codeLine = removeInlineMarkers(line).trim();
         extractedCode.push(codeLine);
       }
     }
@@ -1734,7 +1799,7 @@ function checkDuplicates(examples) {
 
 // src/tester/qualityChecks.ts
 var MIN_ISSUES_COUNT = 0;
-function runQualityChecks(ruleMetadata, examples) {
+function runQualityChecks(ruleFilePath, ruleMetadata, examples) {
   const issues = [];
   const warnings = [];
   const metadataResult = checkRuleMetadata(ruleMetadata);
@@ -1753,6 +1818,595 @@ function runQualityChecks(ruleMetadata, examples) {
   };
 }
 
+// src/tester/quality/checkQualityChecks.ts
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/xpath/extractors/extractLetVariables.ts
+var MIN_STRING_LENGTH5 = 0;
+var MATCH_FULL_INDEX = 0;
+var NOT_FOUND_INDEX2 = -1;
+var QUOTE_MATCH_GROUP_INDEX = 1;
+var VALUE_MATCH_GROUP_INDEX = 2;
+var ZERO_COUNT = 0;
+function extractLetVariables(xpath) {
+  if (xpath.length === MIN_STRING_LENGTH5) return [];
+  const variables = [];
+  const letStartMatch = /let\s+/i.exec(xpath);
+  if (letStartMatch?.index === void 0) {
+    return variables;
+  }
+  const letStartIndex = letStartMatch.index + letStartMatch[MATCH_FULL_INDEX].length;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let parenDepth = 0;
+  let declarationsEnd = NOT_FOUND_INDEX2;
+  for (let i = letStartIndex; i < xpath.length; i++) {
+    const char = xpath.charAt(i);
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+    } else if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+    } else if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "(") {
+        parenDepth++;
+      } else if (char === ")") {
+        parenDepth--;
+      } else if (parenDepth === ZERO_COUNT && xpath.substring(i).toLowerCase().startsWith("return")) {
+        declarationsEnd = i;
+        break;
+      }
+    }
+  }
+  if (declarationsEnd === NOT_FOUND_INDEX2) {
+    return variables;
+  }
+  const declarationsPart = xpath.substring(letStartIndex, declarationsEnd);
+  let inQuote2 = false;
+  let inDoubleQuote2 = false;
+  let parenDepth2 = 0;
+  let currentVarStart = NOT_FOUND_INDEX2;
+  const varDeclarations = [];
+  for (let i = 0; i < declarationsPart.length; i++) {
+    const char = declarationsPart.charAt(i);
+    if (char === "'" && !inDoubleQuote2) {
+      inQuote2 = !inQuote2;
+    } else if (char === '"' && !inQuote2) {
+      inDoubleQuote2 = !inDoubleQuote2;
+    } else if (!inQuote2 && !inDoubleQuote2) {
+      if (char === "(") {
+        parenDepth2++;
+      } else if (char === ")") {
+        parenDepth2--;
+      } else if (char === "$" && parenDepth2 === ZERO_COUNT) {
+        if (currentVarStart >= ZERO_COUNT) {
+          varDeclarations.push({ end: i, start: currentVarStart });
+        }
+        currentVarStart = i;
+      } else if (char === "," && parenDepth2 === ZERO_COUNT && currentVarStart >= ZERO_COUNT) {
+        varDeclarations.push({ end: i, start: currentVarStart });
+        currentVarStart = NOT_FOUND_INDEX2;
+      }
+    }
+  }
+  if (currentVarStart >= ZERO_COUNT) {
+    varDeclarations.push({
+      end: declarationsPart.length,
+      start: currentVarStart
+    });
+  }
+  for (const decl of varDeclarations) {
+    const declText = declarationsPart.substring(decl.start, decl.end).trim();
+    const equalsMatch = /\$([a-zA-Z_][a-zA-Z0-9_]*)\s*:?=\s*(.+)/s.exec(
+      declText
+    );
+    if (equalsMatch) {
+      const varName = `$${equalsMatch[QUOTE_MATCH_GROUP_INDEX]}`;
+      const varValue = equalsMatch[VALUE_MATCH_GROUP_INDEX].trim();
+      variables.push({
+        name: varName,
+        value: varValue
+      });
+    }
+  }
+  return variables;
+}
+
+// src/xpath/extractors/extractHardcodedValues.ts
+var MIN_STRING_LENGTH6 = 0;
+var MATCH_FULL_INDEX2 = 0;
+var NUMBER_VALUE_GROUP_INDEX = 1;
+var QUOTE_GROUP_INDEX = 1;
+var STRING_VALUE_GROUP_INDEX = 2;
+var ZERO_COUNT2 = 0;
+function extractHardcodedValues(xpath) {
+  if (xpath.length === MIN_STRING_LENGTH6) return [];
+  const values = [];
+  let letStart = -1;
+  let letEnd = -1;
+  const letStartMatch = /let\s+/i.exec(xpath);
+  if (letStartMatch?.index !== void 0) {
+    letStart = letStartMatch.index;
+    const letStartIndex = letStartMatch.index + letStartMatch[MATCH_FULL_INDEX2].length;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let parenDepth = 0;
+    for (let i = letStartIndex; i < xpath.length; i++) {
+      const char = xpath.charAt(i);
+      if (char === "'" && !inDoubleQuote) {
+        inSingleQuote = !inSingleQuote;
+      } else if (char === '"' && !inSingleQuote) {
+        inDoubleQuote = !inDoubleQuote;
+      } else if (!inSingleQuote && !inDoubleQuote) {
+        if (char === "(") {
+          parenDepth++;
+        } else if (char === ")") {
+          parenDepth--;
+        } else if (parenDepth === ZERO_COUNT2 && xpath.substring(i).toLowerCase().startsWith("return")) {
+          const returnEnd = i + "return".length;
+          letEnd = returnEnd;
+          break;
+        }
+      }
+    }
+  }
+  const stringPattern = /(['"])([^'"]*)\1/g;
+  let stringMatch = null;
+  while ((stringMatch = stringPattern.exec(xpath)) !== null) {
+    if (letStart >= ZERO_COUNT2 && stringMatch.index >= letStart && stringMatch.index < letEnd) {
+      continue;
+    }
+    const stringValue = stringMatch[STRING_VALUE_GROUP_INDEX];
+    if (stringValue.length === MIN_STRING_LENGTH6) continue;
+    values.push({
+      position: stringMatch.index,
+      type: "string",
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Regex capture groups ensure these exist
+      value: `${stringMatch[QUOTE_GROUP_INDEX]}${stringValue}${stringMatch[QUOTE_GROUP_INDEX]}`
+    });
+  }
+  const numberPattern = /\b([2-9]\d*|0\d+)\b/g;
+  let numberMatch = null;
+  while ((numberMatch = numberPattern.exec(xpath)) !== null) {
+    if (letStart >= ZERO_COUNT2 && numberMatch.index >= letStart && numberMatch.index < letEnd) {
+      continue;
+    }
+    const numberValue = numberMatch[NUMBER_VALUE_GROUP_INDEX];
+    values.push({
+      position: numberMatch.index,
+      type: "number",
+      value: numberValue
+    });
+  }
+  return values;
+}
+
+// src/tester/quality/checkQualityChecks.ts
+var MAX_MESSAGE_LENGTH = 80;
+var MIN_STRING_LENGTH7 = 0;
+var LINE_NUMBER_OFFSET2 = 1;
+var ARRAY_LAST_INDEX_OFFSET = 1;
+var NOT_FOUND_INDEX3 = -1;
+var ZERO_COUNT3 = 0;
+var SINGLE_OCCURRENCE = 1;
+var VERSION_PATTERN = /^Version:\s*(\d+)\.(\d+)\.(\d+)$/;
+var VARIABLE_DOC_PATTERN = /^(\$[a-zA-Z_][a-zA-Z0-9_]*):\s*.+$/;
+var INLINE_VIOLATION_MARKER = "Inline violation marker // \u274C";
+var INLINE_VALID_MARKER = "Inline valid marker // \u2705";
+var NEXT_LINE_OFFSET = 1;
+var VAR_PREFIX_LENGTH = 1;
+function hasAtLeastTwoItems(items) {
+  return items.length > SINGLE_OCCURRENCE;
+}
+function findMessageLineNumber(xmlContent) {
+  const lines = xmlContent.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("message=")) {
+      return i + LINE_NUMBER_OFFSET2;
+    }
+  }
+  return void 0;
+}
+function findDescriptionLineNumber(xmlContent) {
+  const lines = xmlContent.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("<description>")) {
+      return i + LINE_NUMBER_OFFSET2;
+    }
+  }
+  return void 0;
+}
+function findXPathValueLocation(xmlContent) {
+  const lines = xmlContent.split("\n");
+  let inProperties = false;
+  let inXPathProperty = false;
+  let valueStartLine = -1;
+  let valueStartChar = -1;
+  let valueContent = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("<properties>")) {
+      inProperties = true;
+    }
+    if (inProperties && line.includes('name="xpath"')) {
+      inXPathProperty = true;
+    }
+    if (inXPathProperty) {
+      const valueTagIndex = line.indexOf("<value>");
+      if (valueTagIndex !== NOT_FOUND_INDEX3) {
+        valueStartLine = i;
+        valueStartChar = valueTagIndex + "<value>".length;
+        let valueEndIndex = line.indexOf("</value>");
+        if (valueEndIndex !== NOT_FOUND_INDEX3) {
+          valueContent = line.substring(
+            valueStartChar,
+            valueEndIndex
+          );
+        } else {
+          valueContent = line.substring(valueStartChar);
+          for (let j = i + NEXT_LINE_OFFSET; j < lines.length; j++) {
+            const nextLine = lines[j];
+            const endTagIndex = nextLine.indexOf("</value>");
+            if (endTagIndex !== NOT_FOUND_INDEX3) {
+              valueContent += "\n" + nextLine.substring(ZERO_COUNT3, endTagIndex);
+              break;
+            }
+            valueContent += "\n" + nextLine;
+          }
+        }
+        const trimmedContent = valueContent.trim();
+        let actualContentStartLine = valueStartLine;
+        let actualContent = trimmedContent;
+        const cdataIndexInValue = valueContent.indexOf("<![CDATA[");
+        if (cdataIndexInValue !== NOT_FOUND_INDEX3) {
+          const afterCdataStart = valueContent.substring(
+            cdataIndexInValue + "<![CDATA[".length
+          );
+          const cdataEndIndex = afterCdataStart.indexOf("]]>");
+          if (cdataEndIndex !== NOT_FOUND_INDEX3) {
+            actualContent = afterCdataStart.substring(ZERO_COUNT3, cdataEndIndex).trim();
+            const newlineCountToCdata = (valueContent.substring(ZERO_COUNT3, cdataIndexInValue).match(/\n/g) ?? []).length;
+            actualContentStartLine = valueStartLine + newlineCountToCdata + LINE_NUMBER_OFFSET2;
+          }
+        }
+        return {
+          startChar: valueStartChar,
+          startLine: actualContentStartLine + LINE_NUMBER_OFFSET2,
+          valueContent: actualContent.trim()
+        };
+      }
+    }
+    if (line.includes("</properties>")) {
+      break;
+    }
+  }
+  return void 0;
+}
+function calculateXPathLineNumber(xpathValueLocation, positionInXPath) {
+  const xpathBeforePosition = xpathValueLocation.valueContent.substring(
+    ZERO_COUNT3,
+    positionInXPath
+  );
+  const newlineCount = (xpathBeforePosition.match(/\n/g) ?? []).length;
+  return xpathValueLocation.startLine + newlineCount;
+}
+function checkMessageLength(message, messageLine) {
+  if (message === null || message === void 0 || message.length === MIN_STRING_LENGTH7) {
+    return messageLine !== void 0 ? `Line ${String(messageLine)}: message attribute is missing` : "message attribute is missing";
+  }
+  if (message.length > MAX_MESSAGE_LENGTH) {
+    return messageLine !== void 0 ? `Line ${String(messageLine)}: message attribute exceeds ${String(MAX_MESSAGE_LENGTH)} characters (${String(message.length)} chars)` : `message attribute exceeds ${String(MAX_MESSAGE_LENGTH)} characters (${String(message.length)} chars)`;
+  }
+  return null;
+}
+function checkVersionLine(description, descriptionLine) {
+  if (description === null || description === void 0 || description.length === MIN_STRING_LENGTH7) {
+    return descriptionLine !== void 0 ? `Line ${String(descriptionLine)}: description must end with 'Version: X.Y.Z'` : "description must end with 'Version: X.Y.Z'";
+  }
+  const lines = description.split("\n");
+  const lastLineIndex = lines.length - ARRAY_LAST_INDEX_OFFSET;
+  const lastLine = lines[lastLineIndex]?.trim();
+  if (lastLine === void 0 || lastLine.length === MIN_STRING_LENGTH7 || !VERSION_PATTERN.test(lastLine)) {
+    return descriptionLine !== void 0 ? `Line ${String(descriptionLine)}: description must end with 'Version: X.Y.Z' (SemVer format)` : "description must end with 'Version: X.Y.Z' (SemVer format)";
+  }
+  return null;
+}
+function checkXPathHardcodedValues(xpath, xmlContent) {
+  const issues = [];
+  if (xpath === null || xpath === void 0 || xpath.length === MIN_STRING_LENGTH7) {
+    return issues;
+  }
+  const xpathLocation = findXPathValueLocation(xmlContent);
+  if (xpathLocation === void 0) {
+    return issues;
+  }
+  const rawXPath = xpathLocation.valueContent;
+  const hardcodedValues = extractHardcodedValues(rawXPath);
+  if (hardcodedValues.length === MIN_STRING_LENGTH7) {
+    return issues;
+  }
+  const letVariables = extractLetVariables(xpath);
+  const letVariableValues = new Set(
+    letVariables.map((v) => {
+      const normalized = v.value.replace(/^['"]|['"]$/g, "").toLowerCase().trim();
+      return normalized;
+    })
+  );
+  for (const hardcoded of hardcodedValues) {
+    const normalizedValue = hardcoded.value.replace(/^['"]|['"]$/g, "").toLowerCase().trim();
+    if (!letVariableValues.has(normalizedValue)) {
+      const exactLine = calculateXPathLineNumber(
+        xpathLocation,
+        hardcoded.position
+      );
+      issues.push(
+        `Line ${String(exactLine)}: ${hardcoded.value} outside initial let statement`
+      );
+    }
+  }
+  return issues;
+}
+function findVariablePositionInXPath(xpath, varName) {
+  const pattern = new RegExp(
+    `\\$${varName.substring(VAR_PREFIX_LENGTH)}\\s*:?=`
+  );
+  const match = pattern.exec(xpath);
+  return match?.index ?? NOT_FOUND_INDEX3;
+}
+function checkVariableDocumentation(xpath, description, xmlContent) {
+  const issues = [];
+  if (xpath === null || xpath === void 0 || xpath.length === MIN_STRING_LENGTH7) {
+    return issues;
+  }
+  const letVariables = extractLetVariables(xpath);
+  if (letVariables.length === MIN_STRING_LENGTH7) {
+    return issues;
+  }
+  if (description === null || description === void 0 || description.length === MIN_STRING_LENGTH7) {
+    const xpathLocation2 = findXPathValueLocation(xmlContent);
+    for (const variable of letVariables) {
+      const xpathForPosition = xpathLocation2 !== void 0 ? xpathLocation2.valueContent : xpath;
+      const varPosition = findVariablePositionInXPath(
+        xpathForPosition,
+        variable.name
+      );
+      const varLine = xpathLocation2 !== void 0 && varPosition !== NOT_FOUND_INDEX3 ? calculateXPathLineNumber(xpathLocation2, varPosition) : void 0;
+      issues.push(
+        varLine !== void 0 ? `Line ${String(varLine)}: variable ${variable.name} undocumented` : `variable ${variable.name} undocumented`
+      );
+    }
+    return issues;
+  }
+  const descriptionLines = description.split("\n");
+  const documentedVars = /* @__PURE__ */ new Set();
+  for (const line of descriptionLines) {
+    const trimmed = line.trim();
+    const varMatch = VARIABLE_DOC_PATTERN.exec(trimmed);
+    if (varMatch !== null) {
+      const colonIndex = trimmed.indexOf(":");
+      const varName = trimmed.substring(ZERO_COUNT3, colonIndex);
+      documentedVars.add(varName);
+    }
+  }
+  const xpathLocation = findXPathValueLocation(xmlContent);
+  for (const variable of letVariables) {
+    if (!documentedVars.has(variable.name)) {
+      const xpathForPosition = xpathLocation !== void 0 ? xpathLocation.valueContent : xpath;
+      const varPosition = findVariablePositionInXPath(
+        xpathForPosition,
+        variable.name
+      );
+      const varLine = xpathLocation !== void 0 && varPosition !== NOT_FOUND_INDEX3 ? calculateXPathLineNumber(xpathLocation, varPosition) : void 0;
+      issues.push(
+        varLine !== void 0 ? `Line ${String(varLine)}: variable ${variable.name} undocumented` : `variable ${variable.name} undocumented`
+      );
+    }
+  }
+  return issues;
+}
+function extractTextAfterMarker(line, marker) {
+  const markerIndex = line.indexOf(marker);
+  const textAfter = line.substring(markerIndex + marker.length).trim();
+  return textAfter;
+}
+function findMarkerLineNumber(input) {
+  const { exampleIndex, lines, markerLineInExample } = input;
+  let currentExampleIndex = 0;
+  let exampleStart = NOT_FOUND_INDEX3;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("<example>")) {
+      currentExampleIndex++;
+      if (currentExampleIndex === exampleIndex) {
+        exampleStart = i;
+      }
+    }
+    if (exampleStart >= ZERO_COUNT3 && line.includes("</example>")) {
+      const lineOffset = markerLineInExample - LINE_NUMBER_OFFSET2;
+      const estimatedLine = exampleStart + lineOffset + LINE_NUMBER_OFFSET2;
+      if (estimatedLine < i) {
+        return estimatedLine + LINE_NUMBER_OFFSET2;
+      }
+      break;
+    }
+  }
+  return void 0;
+}
+function checkMarkerDescriptions(examples, xmlContent) {
+  const issues = [];
+  const lines = xmlContent.split("\n");
+  const markerDescriptions = /* @__PURE__ */ new Map();
+  for (const example of examples) {
+    const exampleLines = example.content.split("\n");
+    for (const marker of example.violationMarkers) {
+      const markerLineIndex = marker.lineNumber - LINE_NUMBER_OFFSET2;
+      if (markerLineIndex >= ZERO_COUNT3 && markerLineIndex < exampleLines.length) {
+        const markerLine = exampleLines[markerLineIndex];
+        let desc = "";
+        if (markerLine.includes("// \u274C")) {
+          desc = extractTextAfterMarker(markerLine, "// \u274C").trim();
+        } else if (markerLine.includes("// Violation:")) {
+          desc = extractTextAfterMarker(
+            markerLine,
+            "// Violation:"
+          ).trim();
+        } else {
+          desc = marker.description.trim();
+          if (desc === INLINE_VIOLATION_MARKER) {
+            desc = "";
+          }
+        }
+        if (desc.length === MIN_STRING_LENGTH7) {
+          const lineNum = findMarkerLineNumber({
+            exampleIndex: example.exampleIndex,
+            lines,
+            markerLineInExample: marker.lineNumber
+          });
+          issues.push(
+            lineNum !== void 0 ? `Line ${String(lineNum)}: violation has no description` : `Example ${String(example.exampleIndex)}: violation has no description`
+          );
+        } else {
+          if (!markerDescriptions.has(desc)) {
+            markerDescriptions.set(desc, []);
+          }
+          const locations = markerDescriptions.get(desc);
+          const lineNum = findMarkerLineNumber({
+            exampleIndex: example.exampleIndex,
+            lines,
+            markerLineInExample: marker.lineNumber
+          });
+          locations.push({
+            example: example.exampleIndex,
+            line: lineNum ?? ZERO_COUNT3
+          });
+        }
+      }
+    }
+    for (const marker of example.validMarkers) {
+      const markerLineIndex = marker.lineNumber - LINE_NUMBER_OFFSET2;
+      if (markerLineIndex >= ZERO_COUNT3 && markerLineIndex < exampleLines.length) {
+        const markerLine = exampleLines[markerLineIndex];
+        let desc = "";
+        if (markerLine.includes("// \u2705")) {
+          desc = extractTextAfterMarker(markerLine, "// \u2705").trim();
+        } else if (markerLine.includes("// Valid:")) {
+          desc = extractTextAfterMarker(
+            markerLine,
+            "// Valid:"
+          ).trim();
+        } else {
+          desc = marker.description.trim();
+          if (desc === INLINE_VALID_MARKER) {
+            desc = "";
+          }
+        }
+        if (desc.length === MIN_STRING_LENGTH7) {
+          const lineNum = findMarkerLineNumber({
+            exampleIndex: example.exampleIndex,
+            lines,
+            markerLineInExample: marker.lineNumber
+          });
+          issues.push(
+            lineNum !== void 0 ? `Line ${String(lineNum)}: valid has no description` : `Example ${String(example.exampleIndex)}: valid has no description`
+          );
+        } else {
+          if (!markerDescriptions.has(desc)) {
+            markerDescriptions.set(desc, []);
+          }
+          const locations = markerDescriptions.get(desc);
+          const lineNum = findMarkerLineNumber({
+            exampleIndex: example.exampleIndex,
+            lines,
+            markerLineInExample: marker.lineNumber
+          });
+          locations.push({
+            example: example.exampleIndex,
+            line: lineNum ?? ZERO_COUNT3
+          });
+        }
+      }
+    }
+  }
+  for (const [desc, locations] of markerDescriptions.entries()) {
+    if (hasAtLeastTwoItems(locations)) {
+      const [firstLocation, ...restLocations] = locations;
+      const originalLine = firstLocation.line;
+      for (const loc of restLocations) {
+        issues.push(
+          `Line ${String(loc.line)}: duplicate description '${desc}' (line ${String(originalLine)})`
+        );
+      }
+    }
+  }
+  return issues;
+}
+function checkViolationExists(examples, xmlContent) {
+  const hasViolation = examples.some(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter
+    (example) => example.violationMarkers.length > MIN_STRING_LENGTH7
+  );
+  if (!hasViolation) {
+    const lines = xmlContent.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.includes("<example>")) {
+        return `Line ${String(i + LINE_NUMBER_OFFSET2)}: at least one violation marker (// Violation or // \u274C) required`;
+      }
+    }
+    return "at least one violation marker (// Violation or // \u274C) required";
+  }
+  return null;
+}
+function checkQualityChecks(ruleFilePath, ruleMetadata, examples) {
+  const issues = [];
+  try {
+    const xmlContent = readFileSync3(ruleFilePath, "utf-8");
+    const messageLine = findMessageLineNumber(xmlContent);
+    const messageIssue = checkMessageLength(
+      ruleMetadata.message,
+      messageLine
+    );
+    if (messageIssue !== null) {
+      issues.push(messageIssue);
+    }
+    const descriptionLine = findDescriptionLineNumber(xmlContent);
+    const versionIssue = checkVersionLine(
+      ruleMetadata.description,
+      descriptionLine
+    );
+    if (versionIssue !== null) {
+      issues.push(versionIssue);
+    }
+    const xpathIssues = checkXPathHardcodedValues(
+      ruleMetadata.xpath,
+      xmlContent
+    );
+    issues.push(...xpathIssues);
+    const varDocIssues = checkVariableDocumentation(
+      ruleMetadata.xpath,
+      ruleMetadata.description,
+      xmlContent
+    );
+    issues.push(...varDocIssues);
+    const markerIssues = checkMarkerDescriptions(examples, xmlContent);
+    issues.push(...markerIssues);
+    const violationIssue = checkViolationExists(examples, xmlContent);
+    if (violationIssue !== null) {
+      issues.push(violationIssue);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    issues.push(`Error reading rule file: ${errorMessage}`);
+  }
+  const MIN_ISSUES_COUNT2 = 0;
+  return {
+    issues,
+    passed: issues.length === MIN_ISSUES_COUNT2,
+    warnings: []
+  };
+}
+
 // src/tester/RuleTester.ts
 var MIN_EXAMPLES_COUNT2 = 0;
 var MIN_VIOLATIONS_COUNT = 0;
@@ -1808,7 +2462,7 @@ var RuleTester = class {
    * @public
    */
   extractRuleMetadata() {
-    const content = readFileSync3(this.ruleFilePath, "utf-8");
+    const content = readFileSync4(this.ruleFilePath, "utf-8");
     const parser = new DOMParser3();
     const doc = parser.parseFromString(content, "text/xml");
     const ruleElement = doc.getElementsByTagName("rule")[MIN_EXAMPLES_COUNT2];
@@ -1847,7 +2501,7 @@ var RuleTester = class {
    * @public
    */
   extractExamples() {
-    const content = readFileSync3(this.ruleFilePath, "utf-8");
+    const content = readFileSync4(this.ruleFilePath, "utf-8");
     const parser = new DOMParser3();
     const doc = parser.parseFromString(content, "text/xml");
     const exampleNodes = doc.getElementsByTagName("example");
@@ -1906,13 +2560,9 @@ var RuleTester = class {
    */
   async runCoverageTest(skipPMDValidation = false, maxConcurrency = DEFAULT_CONCURRENCY) {
     this.extractExamples();
-    const qualityResult = runQualityChecks(
-      this.ruleMetadata,
-      this.examples
-    );
     const INDEX_OFFSET3 = 1;
     const ZERO_VIOLATIONS = 0;
-    const exampleResults = skipPMDValidation ? (
+    const pmdValidationPromise = skipPMDValidation ? Promise.resolve(
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter for map
       this.examples.map((_example, i) => ({
         actualViolations: ZERO_VIOLATIONS,
@@ -1922,7 +2572,34 @@ var RuleTester = class {
         passed: true,
         testCaseResults: []
       }))
-    ) : await this.validateExamplesWithPMD(maxConcurrency);
+    ) : this.validateExamplesWithPMD(maxConcurrency);
+    const qualityChecksPromise = Promise.resolve(
+      runQualityChecks(
+        this.ruleFilePath,
+        this.ruleMetadata,
+        this.examples
+      )
+    );
+    const newQualityChecksPromise = Promise.resolve(
+      checkQualityChecks(
+        this.ruleFilePath,
+        this.ruleMetadata,
+        this.examples
+      )
+    );
+    const xpathCoveragePromise = Promise.resolve(
+      checkXPathCoverage(
+        this.ruleMetadata.xpath,
+        this.examples,
+        this.ruleFilePath
+      )
+    );
+    const [exampleResults, qualityResult, newQualityChecks, xpathCoverage] = await Promise.all([
+      pmdValidationPromise,
+      qualityChecksPromise,
+      newQualityChecksPromise,
+      xpathCoveragePromise
+    ]);
     this.results.examplesTested = this.examples.length;
     this.results.examplesPassed = exampleResults.filter(
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter
@@ -1941,12 +2618,8 @@ var RuleTester = class {
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter
       (result) => result.testCaseResults
     );
-    const xpathCoverage = checkXPathCoverage(
-      this.ruleMetadata.xpath,
-      this.examples,
-      this.ruleFilePath
-    );
     this.results.xpathCoverage = xpathCoverage;
+    this.results.qualityChecks = newQualityChecks;
     this.results.success = qualityResult.passed && this.examples.length > MIN_EXAMPLES_COUNT2 && this.results.examplesPassed === this.results.examplesTested;
     return Promise.resolve(this.results);
   }
@@ -2103,11 +2776,11 @@ var RuleTester = class {
    */
   findTestCaseLineNumber(exampleIndex, testType) {
     try {
-      const content = readFileSync3(this.ruleFilePath, "utf-8");
+      const content = readFileSync4(this.ruleFilePath, "utf-8");
       const lines = content.split("\n");
-      const NOT_FOUND_INDEX2 = -1;
-      let exampleStart = NOT_FOUND_INDEX2;
-      let exampleEnd = NOT_FOUND_INDEX2;
+      const NOT_FOUND_INDEX4 = -1;
+      let exampleStart = NOT_FOUND_INDEX4;
+      let exampleEnd = NOT_FOUND_INDEX4;
       let currentExampleIndex = 0;
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -2119,7 +2792,7 @@ var RuleTester = class {
           break;
         }
       }
-      if (exampleStart === NOT_FOUND_INDEX2 || exampleEnd === NOT_FOUND_INDEX2) {
+      if (exampleStart === NOT_FOUND_INDEX4 || exampleEnd === NOT_FOUND_INDEX4) {
         return void 0;
       }
       const hasInlineMarkers = () => {
@@ -2131,24 +2804,24 @@ var RuleTester = class {
         }
         return false;
       };
-      const LINE_NUMBER_OFFSET2 = 1;
+      const LINE_NUMBER_OFFSET3 = 1;
       const hasInline = hasInlineMarkers();
       for (let i = exampleStart; i <= exampleEnd; i++) {
         const line = lines[i];
         if (hasInline) {
           const inlineMarkerText = testType === "violation" ? "// \u274C" : "// \u2705";
           if (line.includes(inlineMarkerText)) {
-            return i + LINE_NUMBER_OFFSET2;
+            return i + LINE_NUMBER_OFFSET3;
           }
         } else {
           const sectionMarkerText = testType === "violation" ? "// Violation:" : "// Valid:";
           if (line.includes(sectionMarkerText)) {
-            const NEXT_LINE_OFFSET = 1;
-            for (let j = i + NEXT_LINE_OFFSET; j <= exampleEnd; j++) {
+            const NEXT_LINE_OFFSET2 = 1;
+            for (let j = i + NEXT_LINE_OFFSET2; j <= exampleEnd; j++) {
               const nextLineRaw = lines[j];
               const nextLine = nextLineRaw.trim();
               if (nextLine && !nextLine.startsWith("//") && !nextLine.startsWith("*/") && !nextLine.startsWith("/*") && !nextLine.startsWith("</") && !nextLine.startsWith("<")) {
-                return j + LINE_NUMBER_OFFSET2;
+                return j + LINE_NUMBER_OFFSET3;
               }
             }
           }
@@ -2165,11 +2838,11 @@ var RuleTester = class {
    * @private
    */
   findExampleLineNumber(exampleIndex) {
-    const content = readFileSync3(this.ruleFilePath, "utf-8");
+    const content = readFileSync4(this.ruleFilePath, "utf-8");
     const lines = content.split("\n");
     let currentExampleIndex = 0;
-    const LINE_NUMBER_OFFSET2 = 1;
-    const NOT_FOUND_INDEX2 = -1;
+    const LINE_NUMBER_OFFSET3 = 1;
+    const NOT_FOUND_INDEX4 = -1;
     const foundIndex = lines.findIndex((line) => {
       if (line.includes("<example>")) {
         currentExampleIndex++;
@@ -2177,7 +2850,7 @@ var RuleTester = class {
       }
       return false;
     });
-    return foundIndex === NOT_FOUND_INDEX2 ? void 0 : foundIndex + LINE_NUMBER_OFFSET2;
+    return foundIndex === NOT_FOUND_INDEX4 ? void 0 : foundIndex + LINE_NUMBER_OFFSET3;
   }
   /**
    * Initializes an empty results object for a new test run.
@@ -2295,6 +2968,8 @@ function generateLcovReport(coverageData, outputPath) {
 // src/cli/main.ts
 var EXIT_CODE_SUCCESS = 0;
 var EXIT_CODE_ERROR = 1;
+var PARSE_INT_RADIX = 10;
+var LINE_NUMBER_MATCH_GROUP_INDEX = 1;
 var ARGV_SLICE_INDEX = 2;
 var MIN_ARGS_COUNT = 0;
 var MAX_ARGS_COUNT = 2;
@@ -2320,11 +2995,8 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
   try {
     const tester = new RuleTester(ruleFilePath);
     const result = await tester.runCoverageTest(false, maxConcurrency);
-    const hasCoverageTracker = coverageTracker !== null;
-    const MIN_COVERED_LINES_COUNT = 0;
-    const coveredLines = result.xpathCoverage.coveredLineNumbers;
-    if (hasCoverageTracker && coveredLines && coveredLines.length > MIN_COVERED_LINES_COUNT) {
-      for (const lineNumber of coveredLines) {
+    if (coverageTracker && result.xpathCoverage.coveredLineNumbers) {
+      for (const lineNumber of result.xpathCoverage.coveredLineNumbers) {
         coverageTracker.recordXPathLine(lineNumber);
       }
     }
@@ -2358,12 +3030,42 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
         `  Rule triggers violations: ${result.ruleTriggersViolations ? "\u2705 Yes" : "\u274C No"}`
       );
     }
+    if (result.qualityChecks) {
+      console.log("\n\u2B50 Quality Checks:");
+      if (result.qualityChecks.passed) {
+        console.log("  Status: \u2705 Passed");
+      } else {
+        console.log("  Status: \u26A0\uFE0F Incomplete");
+        const sortedIssues = [...result.qualityChecks.issues].sort(
+          (a, b) => {
+            const lineMatchA = /^Line\s+(\d+):/.exec(a);
+            const lineMatchB = /^Line\s+(\d+):/.exec(b);
+            const lineNumberA = lineMatchA?.[LINE_NUMBER_MATCH_GROUP_INDEX];
+            const lineNumberB = lineMatchB?.[LINE_NUMBER_MATCH_GROUP_INDEX];
+            const lineNumA = lineMatchA ? Number.parseInt(
+              lineNumberA ?? "",
+              PARSE_INT_RADIX
+            ) : Number.MAX_SAFE_INTEGER;
+            const lineNumB = lineMatchB ? Number.parseInt(
+              lineNumberB ?? "",
+              PARSE_INT_RADIX
+            ) : Number.MAX_SAFE_INTEGER;
+            if (lineNumA !== lineNumB) {
+              return lineNumA - lineNumB;
+            }
+            return a.localeCompare(b);
+          }
+        );
+        for (const issue of sortedIssues) {
+          console.log(`  - ${issue}`);
+        }
+      }
+    }
     console.log("\n\u{1F50D} XPath Coverage:");
     if (result.xpathCoverage.overallSuccess) {
       console.log("  Status: \u2705 Complete");
     } else {
-      const INCOMPLETE_STATUS_MESSAGE = "  Status: \u26A0\uFE0F Incomplete";
-      console.log(INCOMPLETE_STATUS_MESSAGE);
+      console.log("  Status: \u26A0\uFE0F Incomplete");
     }
     if (result.xpathCoverage.coverage.length > MIN_COUNT4) {
       console.log(
@@ -2425,7 +3127,7 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
       console.log("\n\u274C Tests failed, incomplete coverage");
     }
     tester.cleanup();
-    const coverageData = coverageTracker !== null ? coverageTracker.getCoverageData() : void 0;
+    const coverageData = coverageTracker ? coverageTracker.getCoverageData() : void 0;
     return {
       coverageData,
       filePath: ruleFilePath,
@@ -2462,8 +3164,7 @@ async function main() {
     console.error("\u274C Invalid path argument");
     process.exit(EXIT_CODE_ERROR);
   }
-  const COVERAGE_FLAG = "--coverage";
-  const hasCoverageFlag = args.length > SECOND_ARG_INDEX && args[SECOND_ARG_INDEX] === COVERAGE_FLAG;
+  const hasCoverageFlag = args.length > SECOND_ARG_INDEX && args[SECOND_ARG_INDEX] === "--coverage";
   if (!existsSync2(pathArg)) {
     console.error(`\u274C Path not found: ${pathArg}`);
     process.exit(EXIT_CODE_ERROR);
@@ -2501,8 +3202,8 @@ async function main() {
   const coverageTrackers = hasCoverageFlag ? /* @__PURE__ */ new Map() : null;
   const tasks = xmlFiles.map(
     (filePath) => async () => {
-      const tracker = coverageTrackers !== null ? coverageTrackers.get(filePath) ?? new CoverageTracker(filePath) : null;
-      if (tracker !== null && coverageTrackers !== null) {
+      const tracker = coverageTrackers ? coverageTrackers.get(filePath) ?? new CoverageTracker(filePath) : null;
+      if (tracker && coverageTrackers) {
         coverageTrackers.set(filePath, tracker);
       }
       return testRuleFile(filePath, tracker, maxExampleConcurrency);
@@ -2532,19 +3233,13 @@ async function main() {
       console.log(`  - ${result.filePath}${errorSuffix}`);
     });
   }
-  if (hasCoverageFlag && coverageTrackers !== null) {
-    const coverageData = Array.from(
-      coverageTrackers.values()
-    ).map(
+  if (hasCoverageFlag && coverageTrackers) {
+    const coverageData = Array.from(coverageTrackers.values()).map(
       (tracker) => tracker.getCoverageData()
     );
-    const COVERAGE_REPORT_PATH = "coverage/lcov.info";
     try {
-      generateLcovReport(coverageData, COVERAGE_REPORT_PATH);
-      console.log(
-        `
-\u{1F4CA} Coverage report generated: ${COVERAGE_REPORT_PATH}`
-      );
+      generateLcovReport(coverageData, "coverage/lcov.info");
+      console.log("\n\u{1F4CA} Coverage report generated: coverage/lcov.info");
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error(