test-pmd-rule 0.1.0

package/dist/test-pmd-rule.js

@@ -0,0 +1,2197 @@
+#!/usr/bin/env node
+
+// src/cli/main.ts
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { resolve as resolve3, extname } from "path";
+import { argv } from "process";
+import { cpus } from "os";
+
+// src/tester/RuleTester.ts
+import { readFileSync as readFileSync3, existsSync } from "fs";
+import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
+
+// src/xpath/extractXPath.ts
+import { readFileSync, realpathSync } from "fs";
+import { resolve } from "path";
+import { DOMParser } from "@xmldom/xmldom";
+var FIRST_ELEMENT_INDEX = 0;
+var MIN_STRING_LENGTH = 0;
+function normalizePath(filePath) {
+  const resolvedPath = resolve(filePath);
+  const canonicalPath = realpathSync(resolvedPath);
+  return canonicalPath;
+}
+function extractXPath(xmlFilePath) {
+  try {
+    const normalizedPath = normalizePath(xmlFilePath);
+    const content = readFileSync(normalizedPath, "utf-8");
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(content, "text/xml");
+    const properties = doc.getElementsByTagName("properties")[FIRST_ELEMENT_INDEX];
+    if (!properties) {
+      return { data: null, success: true };
+    }
+    const xpathProperty = Array.from(
+      properties.getElementsByTagName("property")
+    ).find(
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Element is used for getAttribute
+      (prop) => prop.getAttribute("name") === "xpath"
+    );
+    if (!xpathProperty) {
+      return { data: null, success: true };
+    }
+    const valueElement = xpathProperty.getElementsByTagName("value")[FIRST_ELEMENT_INDEX];
+    if (!valueElement) {
+      return { data: null, success: true };
+    }
+    const { textContent } = valueElement;
+    const trimmed = textContent !== null ? textContent.trim() : null;
+    const hasContent = trimmed !== null && trimmed.length > MIN_STRING_LENGTH;
+    const xpath = hasContent ? trimmed : null;
+    return { data: xpath, success: true };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      error: `Error extracting XPath: ${errorMessage}`,
+      success: false
+    };
+  }
+}
+
+// src/xpath/checkCoverage.ts
+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 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
+  );
+  const nodeTypeMatches2 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)(Method|Field|Class|Type|Condition|Loop|Block|Parameter|Property|Annotation)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const nodeTypeMatches3 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)([A-Z][a-zA-Z]*(?:Method|Class|Field|Condition|Loop|Type)[a-zA-Z]*)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const nodeTypeMatches4 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)(ApexFile|CompilationUnit)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const nodeTypeMatches5 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)(UserClass|UserInterface|UserEnum)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const nodeTypeMatches6 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)(Dml(?:Insert|Update|Delete|Undelete|Upsert|Merge)Statement)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const nodeTypeMatches7 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)((?:Constructor|Values|Map|SizedArray)Initializer)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const nodeTypeMatches8 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)(ModifierNode|KeywordModifier)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const nodeTypeMatches9 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)(TypeRef|Identifier|StandardCondition|WhenValue|WhenType|WhenElse|EnumValue|AnnotationParameter|SoqlOrSoslBinding|FormalComment|MapEntryNode|SuperExpression|ThisVariableExpression|CompoundStatement|BreakStatement|ContinueStatement|EmptyStatement|TriggerDeclaration)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const nodeTypeMatches10 = xpath.matchAll(
+    /(?:\.\/\/|\/\/|\s|\/|\(|\[|,|\|)(SoqlExpression|SoslExpression)(?=\s|$|\[|\(|\/|\)|,|\||]|or|and|not|return|let)/g
+  );
+  const MATCH_INDEX3 = 1;
+  const allMatches = [
+    nodeTypeMatches1,
+    nodeTypeMatches2,
+    nodeTypeMatches3,
+    nodeTypeMatches4,
+    nodeTypeMatches5,
+    nodeTypeMatches6,
+    nodeTypeMatches7,
+    nodeTypeMatches8,
+    nodeTypeMatches9,
+    nodeTypeMatches10
+  ];
+  for (const matches of allMatches) {
+    for (const match of matches) {
+      const nodeType = match[MATCH_INDEX3];
+      nodeTypes.add(nodeType);
+    }
+  }
+  return Array.from(nodeTypes);
+}
+
+// src/xpath/extractors/extractOperators.ts
+var MATCH_INDEX = 1;
+var MIN_STRING_LENGTH2 = 0;
+function extractOperators(xpath) {
+  if (xpath.length === MIN_STRING_LENGTH2) return [];
+  const operators = /* @__PURE__ */ new Set();
+  const opMatches = xpath.matchAll(/@Op\s*=\s*['"]([^'"]+)['"]/g);
+  for (const match of opMatches) {
+    const operator = match[MATCH_INDEX];
+    operators.add(operator);
+  }
+  return Array.from(operators);
+}
+
+// src/xpath/extractors/extractAttributes.ts
+var MATCH_INDEX2 = 1;
+var MIN_STRING_LENGTH3 = 0;
+function extractAttributes(xpath) {
+  if (xpath.length === MIN_STRING_LENGTH3) return [];
+  const attributes = /* @__PURE__ */ new Set();
+  const attrMatches = xpath.matchAll(
+    /@([A-Za-z][A-Za-z0-9]*)(?=\s|$|[\]|\)|,|\||=])/g
+  );
+  for (const match of attrMatches) {
+    const attr = match[MATCH_INDEX2];
+    if (attr !== void 0 && attr.length > MIN_STRING_LENGTH3 && attr !== "Op") {
+      attributes.add(attr);
+    }
+  }
+  return Array.from(attributes);
+}
+
+// src/xpath/extractors/extractConditionals.ts
+function extractConditionals(xpath) {
+  const MIN_STRING_LENGTH5 = 0;
+  if (xpath.length === MIN_STRING_LENGTH5) return [];
+  const conditionals = [];
+  const MATCH_INDEX3 = 1;
+  const notMatches = xpath.matchAll(/not\s*\(([^)]+)\)/g);
+  for (const match of notMatches) {
+    const expression = match[MATCH_INDEX3];
+    const position = match.index;
+    conditionals.push({
+      expression: expression.trim(),
+      position,
+      type: "not"
+    });
+  }
+  const andMatches = xpath.matchAll(/and\s+([^[\]]+)(?=\s*\])/g);
+  for (const match of andMatches) {
+    const expression = match[MATCH_INDEX3];
+    const position = match.index;
+    conditionals.push({
+      expression: expression.trim(),
+      position,
+      type: "and"
+    });
+  }
+  const orMatches = xpath.matchAll(/or\s+([^[\]]+)(?=\s*\])/g);
+  for (const match of orMatches) {
+    const expression = match[MATCH_INDEX3];
+    const position = match.index;
+    conditionals.push({
+      expression: expression.trim(),
+      position,
+      type: "or"
+    });
+  }
+  return conditionals;
+}
+
+// src/xpath/analyzeXPath.ts
+function analyzeXPath(xpath) {
+  if (!xpath) {
+    return {
+      attributes: [],
+      conditionals: [],
+      hasLetExpressions: false,
+      hasUnions: false,
+      nodeTypes: [],
+      operators: [],
+      patterns: []
+    };
+  }
+  const nodeTypes = extractNodeTypes(xpath);
+  const operators = extractOperators(xpath);
+  const attributes = extractAttributes(xpath);
+  const conditionals = extractConditionals(xpath);
+  const hasUnions = xpath.includes("|");
+  const hasLetExpressions = xpath.includes("let ");
+  return {
+    attributes,
+    conditionals,
+    hasLetExpressions,
+    hasUnions,
+    nodeTypes,
+    operators,
+    patterns: []
+    // Reserved for future pattern analysis
+  };
+}
+
+// src/xpath/checkCoverage.ts
+var MIN_COUNT = 0;
+var NOT_FOUND_INDEX = -1;
+var LINE_OFFSET = 1;
+function findAttributeLineNumber(ruleFilePath, xpath, attribute) {
+  try {
+    const content = readFileSync2(ruleFilePath, "utf-8");
+    const lines = content.split("\n");
+    const attributePattern = `@${attribute}`;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const hasXPath = line.includes("xpath");
+      const hasValue = line.includes("value");
+      const hasAttribute = line.includes(attributePattern);
+      if (hasXPath && hasValue && hasAttribute) {
+        return i + LINE_OFFSET;
+      }
+    }
+    let inXPathSection = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.includes("<property") && line.includes('name="xpath"')) {
+        inXPathSection = true;
+      }
+      if (inXPathSection && line.includes(attributePattern)) {
+        return i + LINE_OFFSET;
+      }
+      if (inXPathSection && line.includes("</property>")) {
+        inXPathSection = false;
+      }
+    }
+    const xpathIndex = xpath.indexOf(attributePattern);
+    if (xpathIndex !== NOT_FOUND_INDEX) {
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes("<value>")) {
+          const xpathBeforeAttribute = xpath.substring(
+            MIN_COUNT,
+            xpathIndex
+          );
+          const newlineMatches = xpathBeforeAttribute.match(/\n/g);
+          const newlineCount = newlineMatches ? newlineMatches.length : MIN_COUNT;
+          return i + LINE_OFFSET + newlineCount;
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function findNodeTypeLineNumber(ruleFilePath, xpath, nodeType) {
+  try {
+    const content = readFileSync2(ruleFilePath, "utf-8");
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const hasXPath = line.includes("xpath");
+      const hasValue = line.includes("value");
+      const hasNodeType = line.includes(nodeType);
+      if (hasXPath && hasValue && hasNodeType) {
+        return i + LINE_OFFSET;
+      }
+    }
+    let inXPathSection = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.includes("<property") && line.includes('name="xpath"')) {
+        inXPathSection = true;
+      }
+      if (inXPathSection && line.includes(nodeType)) {
+        return i + LINE_OFFSET;
+      }
+      if (inXPathSection && line.includes("</property>")) {
+        inXPathSection = false;
+      }
+    }
+    const xpathIndex = xpath.indexOf(nodeType);
+    if (xpathIndex !== NOT_FOUND_INDEX) {
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes("<value>")) {
+          const xpathBeforeNodeType = xpath.substring(
+            MIN_COUNT,
+            xpathIndex
+          );
+          const newlineMatches = xpathBeforeNodeType.match(/\n/g);
+          const newlineCount = newlineMatches ? newlineMatches.length : MIN_COUNT;
+          return i + LINE_OFFSET + newlineCount;
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function checkNodeTypeCoverage(nodeTypes, content, options) {
+  const lineNumberCollector = options?.lineNumberCollector;
+  const lowerContent = content.toLowerCase();
+  const foundNodeTypes = [];
+  const missingNodeTypes = [];
+  for (const nodeType of nodeTypes) {
+    let isCovered = false;
+    switch (nodeType) {
+      case "BinaryExpression":
+        isCovered = /[+\-*/=<>!&|]{1,2}/.test(content);
+        break;
+      case "LiteralExpression":
+        isCovered = /\b\d+(\.\d+)?\b|'(?:[^'\\]|\\.)*'|"[^"]*"|\bnull\b|\btrue\b|\bfalse\b/.test(
+          lowerContent
+        );
+        break;
+      case "ModifierNode":
+        isCovered = /\b(static|final|public|private|protected)\b/.test(
+          lowerContent
+        );
+        break;
+      case "Annotation":
+        isCovered = /@\w+/.test(content);
+        break;
+      case "AnnotationParameter":
+        isCovered = /@\w+\([^)]+\)/.test(content);
+        break;
+      case "IfBlockStatement":
+        isCovered = /\bif\b/.test(lowerContent);
+        break;
+      case "SwitchStatement":
+        isCovered = /\bswitch\b/.test(lowerContent);
+        break;
+      case "ForLoopStatement":
+        isCovered = /\bfor\s*\(/.test(lowerContent);
+        break;
+      case "ForEachStatement":
+        isCovered = /\bfor\s*\([^:]+:[^)]+\)/.test(lowerContent);
+        break;
+      case "WhileLoopStatement":
+        isCovered = /\bwhile\b/.test(lowerContent);
+        break;
+      case "DoWhileLoopStatement":
+        isCovered = /\bdo\b/.test(lowerContent);
+        break;
+      case "TernaryExpression":
+        isCovered = /\?\s*[^:]+\s*:\s*[^;]+/.test(content);
+        break;
+      case "MethodCallExpression":
+        isCovered = /\w+\s*\(/.test(content);
+        break;
+      case "StandardCondition":
+        isCovered = true;
+        break;
+      default:
+        isCovered = lowerContent.includes(nodeType.toLowerCase());
+        break;
+    }
+    if (isCovered) {
+      foundNodeTypes.push(nodeType);
+    } else {
+      missingNodeTypes.push(nodeType);
+    }
+  }
+  const missingList = missingNodeTypes.length > MIN_COUNT ? missingNodeTypes.map((item) => {
+    if (options !== void 0) {
+      const ruleFilePathValue = options.ruleFilePath;
+      const xpathValue = options.xpath;
+      const lineNumber = findNodeTypeLineNumber(
+        ruleFilePathValue,
+        xpathValue,
+        item
+      );
+      if (lineNumber !== null && lineNumberCollector) {
+        lineNumberCollector(lineNumber);
+      }
+      return lineNumber !== null ? ` - Line ${String(lineNumber)}: ${item}` : ` - ${item}`;
+    }
+    return ` - ${item}`;
+  }).join("\n") : "";
+  const missingText = missingNodeTypes.length > MIN_COUNT ? `Missing:
+${missingList}` : "";
+  const description = missingText.length > MIN_COUNT ? missingText : "";
+  return {
+    count: foundNodeTypes.length,
+    description,
+    required: nodeTypes.length,
+    type: "violation"
+  };
+}
+var MAX_EXPRESSION_LENGTH = 50;
+function truncateExpression(expression, maxLength) {
+  const normalized = expression.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.substring(MIN_COUNT, maxLength)}...`;
+}
+function checkConditionalCoverage(conditionals, content) {
+  const lowerContent = content.toLowerCase();
+  const foundConditionals = [];
+  const missingConditionals = [];
+  for (const conditional of conditionals) {
+    const exprLower = conditional.expression.toLowerCase();
+    let isCovered = false;
+    isCovered = lowerContent.includes(exprLower) || lowerContent.includes("if");
+    if (isCovered) {
+      const displayExpr = truncateExpression(
+        conditional.expression,
+        MAX_EXPRESSION_LENGTH
+      );
+      foundConditionals.push(` - ${conditional.type}: ${displayExpr}`);
+    } else {
+      const displayExpr = truncateExpression(
+        conditional.expression,
+        MAX_EXPRESSION_LENGTH
+      );
+      missingConditionals.push(` - ${conditional.type}: ${displayExpr}`);
+    }
+  }
+  const missingList = missingConditionals.length > MIN_COUNT ? missingConditionals : [];
+  const missingText = missingList.length > MIN_COUNT ? `Missing:
+${missingList.join("\n")}` : "";
+  const description = missingText.length > MIN_COUNT ? missingText : "";
+  return {
+    count: foundConditionals.length,
+    description,
+    required: conditionals.length,
+    type: "violation"
+  };
+}
+function checkAttributeCoverage(attributes, content, options) {
+  const lineNumberCollector = options?.lineNumberCollector;
+  const lowerContent = content.toLowerCase();
+  const foundAttributes = [];
+  const missingAttributes = [];
+  for (const attr of attributes) {
+    let isCovered = false;
+    switch (attr) {
+      case "String":
+        isCovered = /'(?:[^'\\]|\\.)*'|"[^"]*"/.test(content);
+        break;
+      case "Null":
+        isCovered = /\bnull\b/.test(lowerContent);
+        break;
+      case "LiteralType":
+        isCovered = /\b\d+(\.\d+)?\b/.test(content);
+        break;
+      case "Image":
+        isCovered = /\b\d+(\.\d+)?\b|'(?:[^'\\]|\\.)*'|"[^"]*"|\bnull\b|\btrue\b|\bfalse\b/.test(
+          lowerContent
+        );
+        break;
+      case "Static":
+        isCovered = /\bstatic\b/.test(lowerContent);
+        break;
+      case "Final":
+        isCovered = /\bfinal\b/.test(lowerContent);
+        break;
+      case "Name":
+        isCovered = /@\w+\([^)]*\w+\s*=/.test(content) || lowerContent.includes(attr.toLowerCase());
+        break;
+      case "MethodName":
+        isCovered = /\w+\.\w+\s*\(|\w+\s*\(/.test(content);
+        break;
+      case "Value":
+        isCovered = /@\w+\([^)]*=\s*[^)]+\)/.test(content);
+        break;
+      default:
+        isCovered = lowerContent.includes(attr.toLowerCase());
+        break;
+    }
+    if (isCovered) {
+      foundAttributes.push(attr);
+    } else {
+      missingAttributes.push(attr);
+    }
+  }
+  const missingList = missingAttributes.length > MIN_COUNT ? missingAttributes.map((item) => {
+    const ruleFilePath = options?.ruleFilePath;
+    const xpathValue = options?.xpath;
+    const hasOptions = ruleFilePath !== void 0 && xpathValue !== void 0;
+    if (hasOptions) {
+      const lineNumber = findAttributeLineNumber(
+        ruleFilePath,
+        xpathValue,
+        item
+      );
+      if (lineNumber !== null && lineNumberCollector) {
+        lineNumberCollector(lineNumber);
+      }
+      return lineNumber !== null ? ` - Line ${String(lineNumber)}: ${item}` : ` - ${item}`;
+    }
+    return ` - ${item}`;
+  }).join("\n") : "";
+  const missingText = missingAttributes.length > MIN_COUNT ? `Missing:
+${missingList}` : "";
+  const description = missingText.length > MIN_COUNT ? missingText : "";
+  return {
+    count: foundAttributes.length,
+    description,
+    required: attributes.length,
+    type: "violation"
+  };
+}
+function checkOperatorCoverage(operators, content) {
+  const lowerContent = content.toLowerCase();
+  const foundOperators = [];
+  const missingOperators = [];
+  for (const op of operators) {
+    const opLower = op.toLowerCase();
+    if (lowerContent.includes(opLower)) {
+      foundOperators.push(op);
+    } else {
+      missingOperators.push(op);
+    }
+  }
+  const foundList = foundOperators.length > MIN_COUNT ? foundOperators.map((item) => ` - ${item}`).join("\n") : "";
+  const missingList = missingOperators.length > MIN_COUNT ? missingOperators.map((item) => ` - ${item}`).join("\n") : "";
+  const foundText = foundList;
+  const missingText = missingOperators.length > MIN_COUNT ? `Missing:
+${missingList}` : "";
+  const hasFound = foundText.length > MIN_COUNT;
+  const hasMissing = missingText.length > MIN_COUNT;
+  let description = "";
+  if (hasFound) {
+    description = hasMissing ? `${foundText}
+${missingText}` : foundText;
+  }
+  if (!hasFound && hasMissing) {
+    description = missingText;
+  }
+  return {
+    count: foundOperators.length,
+    description,
+    required: operators.length,
+    type: "violation"
+  };
+}
+function checkXPathCoverage(xpath, examples, ruleFilePath) {
+  const hasXPath = xpath !== null && xpath !== void 0 && xpath.length > MIN_COUNT;
+  if (!hasXPath || examples.length === MIN_COUNT) {
+    return {
+      coverage: [],
+      overallSuccess: false,
+      uncoveredBranches: []
+    };
+  }
+  const analysis = analyzeXPath(xpath);
+  const allContent = examples.map((ex) => ex.content).join("\n").toLowerCase();
+  const coverageResults = [];
+  const uncoveredBranches = [];
+  const coveredLineNumbers = /* @__PURE__ */ new Set();
+  if (analysis.nodeTypes.length > MIN_COUNT) {
+    const ruleFilePathValue = ruleFilePath;
+    const xpathValue = xpath;
+    const hasRuleFilePath = ruleFilePathValue !== void 0 && ruleFilePathValue.length > MIN_COUNT;
+    const hasXpathValue = xpathValue.length > MIN_COUNT;
+    const nodeTypeOptions = hasRuleFilePath && hasXpathValue ? {
+      lineNumberCollector: (lineNumber) => {
+        coveredLineNumbers.add(lineNumber);
+      },
+      ruleFilePath: ruleFilePathValue,
+      xpath: xpathValue
+    } : void 0;
+    const nodeTypeEvidence = checkNodeTypeCoverage(
+      analysis.nodeTypes,
+      allContent,
+      nodeTypeOptions
+    );
+    const nodeTypeSuccess = nodeTypeEvidence.count >= nodeTypeEvidence.required;
+    coverageResults.push({
+      details: [],
+      evidence: [nodeTypeEvidence],
+      message: `Node types: ${String(nodeTypeEvidence.count)}/${String(analysis.nodeTypes.length)} covered`,
+      success: nodeTypeSuccess
+    });
+    if (!nodeTypeSuccess) {
+      uncoveredBranches.push(
+        `Node types: ${analysis.nodeTypes.join(", ")}`
+      );
+    }
+  }
+  if (analysis.conditionals.length > MIN_COUNT) {
+    const conditionalEvidence = checkConditionalCoverage(
+      analysis.conditionals,
+      allContent
+    );
+    const conditionalSuccess = conditionalEvidence.count >= conditionalEvidence.required;
+    coverageResults.push({
+      details: [],
+      evidence: [conditionalEvidence],
+      message: `Conditionals: ${String(conditionalEvidence.count)}/${String(analysis.conditionals.length)} covered`,
+      success: conditionalSuccess
+    });
+    if (!conditionalSuccess) {
+      uncoveredBranches.push(
+        `Conditionals: ${analysis.conditionals.map((c) => c.expression).join(", ")}`
+      );
+    }
+  }
+  if (analysis.attributes.length > MIN_COUNT) {
+    const ruleFilePathValue = ruleFilePath;
+    const xpathValue = xpath;
+    const hasRuleFilePath = ruleFilePathValue !== void 0 && ruleFilePathValue.length > MIN_COUNT;
+    const hasXpathValue = xpathValue.length > MIN_COUNT;
+    const attributeOptions = hasRuleFilePath && hasXpathValue ? {
+      lineNumberCollector: (lineNumber) => {
+        coveredLineNumbers.add(lineNumber);
+      },
+      ruleFilePath: ruleFilePathValue,
+      xpath: xpathValue
+    } : void 0;
+    const attributeEvidence = checkAttributeCoverage(
+      analysis.attributes,
+      allContent,
+      attributeOptions
+    );
+    const attributeSuccess = attributeEvidence.count >= attributeEvidence.required;
+    coverageResults.push({
+      details: [],
+      evidence: [attributeEvidence],
+      message: `Attributes: ${String(attributeEvidence.count)}/${String(analysis.attributes.length)} covered`,
+      success: attributeSuccess
+    });
+    if (!attributeSuccess) {
+      uncoveredBranches.push(
+        `Attributes: ${analysis.attributes.join(", ")}`
+      );
+    }
+  }
+  if (analysis.operators.length > MIN_COUNT) {
+    const operatorEvidence = checkOperatorCoverage(
+      analysis.operators,
+      allContent
+    );
+    const operatorSuccess = operatorEvidence.count >= operatorEvidence.required;
+    coverageResults.push({
+      details: [],
+      evidence: [operatorEvidence],
+      message: `Operators: ${String(operatorEvidence.count)}/${String(analysis.operators.length)} covered`,
+      success: operatorSuccess
+    });
+    if (!operatorSuccess) {
+      uncoveredBranches.push(
+        `Operators: ${analysis.operators.join(", ")}`
+      );
+    }
+  }
+  const overallSuccess = coverageResults.length === MIN_COUNT || coverageResults.every(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter for every
+    (result) => result.success
+  );
+  return {
+    coverage: coverageResults,
+    coveredLineNumbers: Array.from(coveredLineNumbers),
+    overallSuccess,
+    uncoveredBranches
+  };
+}
+
+// src/parser/extractMarkers.ts
+var LINE_NUMBER_OFFSET = 1;
+function extractMarkers(exampleContent) {
+  const lines = exampleContent.split("\n");
+  const violationMarkers = [];
+  const validMarkers = [];
+  const hasInlineMarkersInExample = exampleContent.includes("// \u274C") || exampleContent.includes("// \u2705");
+  lines.forEach((line, index) => {
+    const trimmed = line.trim();
+    const lineNumber = index + LINE_NUMBER_OFFSET;
+    if (trimmed.includes("// \u274C")) {
+      violationMarkers.push({
+        description: "Inline violation marker // \u274C",
+        index: violationMarkers.length,
+        isViolation: true,
+        lineNumber
+      });
+    } else if (trimmed.includes("// \u2705")) {
+      validMarkers.push({
+        description: "Inline valid marker // \u2705",
+        index: validMarkers.length,
+        isViolation: false,
+        lineNumber
+      });
+    }
+    if (!hasInlineMarkersInExample) {
+      if (trimmed.startsWith("// Violation:")) {
+        const description = trimmed.substring("// Violation:".length).trim();
+        violationMarkers.push({
+          description,
+          index: violationMarkers.length,
+          isViolation: true,
+          lineNumber
+        });
+      } else if (trimmed.startsWith("// Valid:")) {
+        const description = trimmed.substring("// Valid:".length).trim();
+        validMarkers.push({
+          description,
+          index: validMarkers.length,
+          isViolation: false,
+          lineNumber
+        });
+      }
+    }
+  });
+  return { validMarkers, violationMarkers };
+}
+
+// src/parser/parseExample.ts
+var EMPTY_STRING_INDEX = 0;
+function parseExample(exampleContent) {
+  const lines = exampleContent.split("\n");
+  const violations = [];
+  const valids = [];
+  let currentMode = null;
+  const { validMarkers, violationMarkers } = extractMarkers(exampleContent);
+  const hasInlineMarkersInExample = exampleContent.includes("// \u274C") || exampleContent.includes("// \u2705");
+  lines.forEach((line) => {
+    const trimmed = line.trim();
+    let lineMode = currentMode;
+    if (trimmed.includes("// \u274C")) {
+      lineMode = "violation";
+    } else if (trimmed.includes("// \u2705")) {
+      lineMode = "valid";
+    }
+    if (trimmed.startsWith("// Violation:")) {
+      currentMode = "violation";
+      if (!hasInlineMarkersInExample) {
+      }
+    } else if (trimmed.startsWith("// Valid:")) {
+      currentMode = "valid";
+      if (!hasInlineMarkersInExample) {
+      }
+    } else if (trimmed && !trimmed.startsWith("//") && trimmed !== "") {
+      let codeLine = line;
+      if (line.includes("// \u274C")) {
+        const splitResult = line.split("// \u274C");
+        codeLine = splitResult[EMPTY_STRING_INDEX].trim();
+      } else if (line.includes("// \u2705")) {
+        const splitResult = line.split("// \u2705");
+        codeLine = splitResult[EMPTY_STRING_INDEX].trim();
+      }
+      if (lineMode === "violation") {
+        violations.push(codeLine);
+      } else if (lineMode === "valid") {
+        valids.push(codeLine);
+      }
+    }
+  });
+  return {
+    content: exampleContent,
+    validMarkers,
+    valids,
+    violationMarkers,
+    violations
+  };
+}
+
+// src/parser/createTestFile.ts
+import { writeFileSync } from "fs";
+import tmp from "tmp";
+var EMPTY_LENGTH = 0;
+var FIRST_CAPTURE_GROUP_INDEX = 1;
+var SECOND_CAPTURE_GROUP_INDEX = 2;
+function inferReturnType(code, methodName) {
+  if (new RegExp(`\\b${methodName}\\s*\\(\\s*\\)\\s*[><=!]+\\s*\\d+`).test(
+    code
+  )) {
+    return "Integer";
+  }
+  if (new RegExp(`switch\\s+on\\s+${methodName}\\s*\\(`).test(code)) {
+    return "String";
+  }
+  if (new RegExp(`${methodName}\\s*\\(\\s*\\)\\s*\\?`).test(code)) {
+    return "Boolean";
+  }
+  if (new RegExp(`for\\s*\\([^:]*:\\s*${methodName}\\s*\\(`).test(code)) {
+    return "List<String>";
+  }
+  if (new RegExp(`Set<[^>]+>\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Set<String>";
+  }
+  if (new RegExp(
+    `Map<[^>]+,\\s*[^>]+>\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`
+  ).test(code)) {
+    return "Map<String, Integer>";
+  }
+  if (new RegExp(`Decimal\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Decimal";
+  }
+  if (new RegExp(`Double\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Double";
+  }
+  if (new RegExp(`Long\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Long";
+  }
+  if (new RegExp(`Date\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Date";
+  }
+  if (new RegExp(`Datetime\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Datetime";
+  }
+  if (new RegExp(`Time\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Time";
+  }
+  if (new RegExp(`Blob\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Blob";
+  }
+  if (new RegExp(`Id\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Id";
+  }
+  if (new RegExp(`(?:while|do)\\s*\\(\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Boolean";
+  }
+  if (new RegExp(`Object\\s+\\w+\\s*=\\s*${methodName}\\s*\\(`).test(code)) {
+    return "Object";
+  }
+  return "Boolean";
+}
+function generateReturnValue(returnType) {
+  const listRegex = /^List<(.+)>$/;
+  const listMatch = listRegex.exec(returnType);
+  const listInnerType = listMatch?.[FIRST_CAPTURE_GROUP_INDEX];
+  if (listInnerType !== void 0 && listInnerType.length > EMPTY_LENGTH) {
+    return `return new List<${listInnerType}>();`;
+  }
+  const setRegex = /^Set<(.+)>$/;
+  const setMatch = setRegex.exec(returnType);
+  const setInnerType = setMatch?.[FIRST_CAPTURE_GROUP_INDEX];
+  if (setInnerType !== void 0 && setInnerType.length > EMPTY_LENGTH) {
+    return `return new Set<${setInnerType}>();`;
+  }
+  const mapRegex = /^Map<(.+),\s*(.+)>$/;
+  const mapMatch = mapRegex.exec(returnType);
+  const mapKeyType = mapMatch?.[FIRST_CAPTURE_GROUP_INDEX];
+  const mapValueType = mapMatch?.[SECOND_CAPTURE_GROUP_INDEX];
+  if (mapKeyType !== void 0 && mapValueType !== void 0 && mapKeyType.length > EMPTY_LENGTH && mapValueType.length > EMPTY_LENGTH) {
+    return `return new Map<${mapKeyType}, ${mapValueType}>();`;
+  }
+  switch (returnType) {
+    case "Integer":
+      return "return 1;";
+    case "String":
+      return "return 'test';";
+    case "Boolean":
+      return "return true;";
+    case "Decimal":
+      return "return 1.0;";
+    case "Double":
+      return "return 1.0;";
+    case "Long":
+      return "return 1000L;";
+    case "Date":
+      return "return Date.newInstance(2024, 1, 1);";
+    case "Datetime":
+      return "return Datetime.newInstance(2024, 1, 1);";
+    case "Time":
+      return "return Time.newInstance(0, 0, 0, 0);";
+    case "Blob":
+      return "return Blob.valueOf('test');";
+    case "Id":
+      return "return '001000000000000000';";
+    case "Object":
+      return "return null;";
+    // All types from inferReturnType are handled above
+    // TypeScript ensures exhaustiveness, so no default needed
+    // However, we keep a default for runtime safety in case inferReturnType is extended
+    default:
+      return "return null;";
+  }
+}
+function extractHelperMethods(codeLines) {
+  const methods = /* @__PURE__ */ new Map();
+  const fullCode = codeLines.join("\n");
+  const methodCallRegex = /\b([a-zA-Z_]\w*)\s*\(/g;
+  let match = null;
+  const foundMethods = /* @__PURE__ */ new Set();
+  const apexKeywords = [
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "default",
+    "try",
+    "catch",
+    "finally",
+    "class",
+    "interface",
+    "enum",
+    "public",
+    "private",
+    "protected",
+    "static",
+    "final",
+    "abstract",
+    "void",
+    "return",
+    "new",
+    "this",
+    "super",
+    "extends",
+    "implements",
+    "instanceof",
+    "System",
+    "debug",
+    "List",
+    "Map",
+    "Set",
+    "String",
+    "Integer",
+    "Boolean",
+    "Double",
+    "Date",
+    "Datetime"
+  ];
+  while ((match = methodCallRegex.exec(fullCode)) !== null) {
+    const [, methodName] = match;
+    if (methodName !== void 0 && apexKeywords.includes(methodName)) {
+      continue;
+    }
+    foundMethods.add(methodName);
+  }
+  for (const methodName of foundMethods) {
+    const returnType = inferReturnType(fullCode, methodName);
+    const validReturnType = returnType;
+    const methodSignature = `public ${validReturnType} ${methodName}() {
+        ${generateReturnValue(validReturnType)}
+    }`;
+    methods.set(methodName, methodSignature);
+  }
+  return Array.from(methods.values());
+}
+function createTestFile({
+  exampleContent,
+  exampleIndex,
+  includeViolations = true,
+  includeValids = true
+}) {
+  const tmpFile = tmp.fileSync({
+    keep: true,
+    postfix: ".cls",
+    prefix: `rule-test-example-${String(exampleIndex)}-`
+  });
+  const tempFile = tmpFile.name;
+  const parsed = parseExample(exampleContent);
+  let classContent = `public class TestClass${String(exampleIndex)} {
+`;
+  let codeToInclude = [];
+  if (includeViolations && !includeValids) {
+    codeToInclude = parsed.violations;
+  } else if (includeValids && !includeViolations) {
+    codeToInclude = parsed.valids;
+  } else {
+    codeToInclude = [...parsed.violations, ...parsed.valids];
+  }
+  if (codeToInclude.length > EMPTY_LENGTH) {
+    classContent += `    public void testMethod${String(exampleIndex)}() {
+`;
+    codeToInclude.forEach((line) => {
+      classContent += `        ${line}
+`;
+    });
+    classContent += `    }
+`;
+  }
+  const helperMethods = extractHelperMethods(codeToInclude);
+  for (const method of helperMethods) {
+    classContent += `    ${method}
+`;
+  }
+  classContent += "}\n";
+  writeFileSync(tempFile, classContent, "utf-8");
+  return {
+    filePath: tempFile,
+    hasValids: parsed.valids.length > EMPTY_LENGTH,
+    hasViolations: parsed.violations.length > EMPTY_LENGTH,
+    validCount: parsed.valids.length,
+    violationCount: parsed.violations.length
+  };
+}
+
+// src/pmd/runPMD.ts
+import { execFileSync } from "child_process";
+import { resolve as resolve2 } from "path";
+
+// src/pmd/parseViolations.ts
+import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
+var DEFAULT_LINE = 0;
+var DEFAULT_COLUMN = 0;
+var DEFAULT_PRIORITY = "5";
+var DEFAULT_MESSAGE = "";
+var RADIX = 10;
+var MIN_STRING_LENGTH4 = 0;
+var MIN_TEXT_LENGTH = 0;
+function parseViolations(xmlOutput) {
+  const parser = new DOMParser2();
+  const doc = parser.parseFromString(xmlOutput, "text/xml");
+  const violations = [];
+  const fileNodes = Array.from(doc.getElementsByTagName("file"));
+  for (const fileNode of fileNodes) {
+    const violationNodes = Array.from(
+      fileNode.getElementsByTagName("violation")
+    );
+    for (const violationNode of violationNodes) {
+      const beginlineAttr = violationNode.getAttribute("beginline");
+      const begincolumnAttr = violationNode.getAttribute("begincolumn");
+      const priorityAttr = violationNode.getAttribute("priority");
+      const ruleAttr = violationNode.getAttribute("rule");
+      const messageAttr = violationNode.getAttribute("message");
+      const rawTextContent = violationNode.textContent;
+      const trimmedText = rawTextContent.trim();
+      const hasTextContent = trimmedText.length > MIN_TEXT_LENGTH;
+      const textContent = hasTextContent ? trimmedText : DEFAULT_MESSAGE;
+      const hasBeginline = beginlineAttr !== null && beginlineAttr.length > MIN_STRING_LENGTH4;
+      const line = parseInt(
+        hasBeginline ? beginlineAttr : String(DEFAULT_LINE),
+        RADIX
+      );
+      const hasBegincolumn = begincolumnAttr !== null && begincolumnAttr.length > MIN_STRING_LENGTH4;
+      const column = parseInt(
+        hasBegincolumn ? begincolumnAttr : String(DEFAULT_COLUMN),
+        RADIX
+      );
+      const hasMessageAttr = messageAttr !== null && messageAttr.length > MIN_STRING_LENGTH4;
+      const message = hasMessageAttr ? messageAttr : textContent;
+      const hasPriorityAttr = priorityAttr !== null && priorityAttr.length > MIN_STRING_LENGTH4;
+      const priority = parseInt(
+        hasPriorityAttr ? priorityAttr : DEFAULT_PRIORITY,
+        RADIX
+      );
+      const hasRuleAttr = ruleAttr !== null && ruleAttr.length > MIN_STRING_LENGTH4;
+      const rule = hasRuleAttr ? ruleAttr : DEFAULT_MESSAGE;
+      const violation = {
+        column,
+        line,
+        message,
+        priority,
+        rule
+      };
+      violations.push(violation);
+    }
+  }
+  return violations;
+}
+
+// src/pmd/runPMD.ts
+var MIN_OUTPUT_LENGTH = 0;
+var EMPTY_STRING = "";
+async function runPMD(apexFilePath, rulesetPath) {
+  try {
+    const absoluteApexPath = resolve2(apexFilePath);
+    const absoluteRulesetPath = resolve2(rulesetPath);
+    const result = execFileSync(
+      "pmd",
+      [
+        "check",
+        "--no-cache",
+        "--no-progress",
+        "-d",
+        absoluteApexPath,
+        "-R",
+        absoluteRulesetPath,
+        "-f",
+        "xml"
+      ],
+      {
+        cwd: process.cwd(),
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 3e4
+      }
+    );
+    const violations = parseViolations(result);
+    return {
+      data: {
+        violations
+      },
+      success: true
+    };
+  } catch (error) {
+    const execError = error;
+    if (execError.code === "ENOENT") {
+      return {
+        error: "PMD CLI not available. Please install PMD to run tests. Visit: https://pmd.github.io/pmd/pmd_userdocs_installation.html",
+        success: false
+      };
+    }
+    const xmlOutput = execError.stdout ?? EMPTY_STRING;
+    const xmlOutputString = typeof xmlOutput === "string" ? xmlOutput : xmlOutput.toString();
+    if (xmlOutputString.trim().length > MIN_OUTPUT_LENGTH) {
+      try {
+        const violations = parseViolations(xmlOutputString);
+        return {
+          data: {
+            violations
+          },
+          success: true
+        };
+      } catch {
+      }
+    }
+    const errorMessage = execError.message ?? "Unknown error";
+    let fullErrorMessage = `PMD execution failed: ${errorMessage}`;
+    if (execError.stderr !== void 0) {
+      const stderr = typeof execError.stderr === "string" ? execError.stderr : execError.stderr.toString();
+      if (stderr.trim().length > MIN_OUTPUT_LENGTH) {
+        fullErrorMessage += `
+PMD stderr:
+${stderr}`;
+      }
+    }
+    if (execError.stdout !== void 0) {
+      const stdout = typeof execError.stdout === "string" ? execError.stdout : execError.stdout.toString();
+      if (stdout.length > MIN_OUTPUT_LENGTH) {
+        fullErrorMessage += `
+PMD stdout:
+${stdout}`;
+      }
+    }
+    return {
+      error: fullErrorMessage,
+      success: false
+    };
+  }
+}
+
+// src/tester/quality/checkRuleMetadata.ts
+var MIN_RULE_NAME_LENGTH = 3;
+var MIN_MESSAGE_LENGTH = 10;
+var MIN_DESCRIPTION_LENGTH = 20;
+var MIN_HARDCODED_STRING_LENGTH = 4;
+var MIN_ERROR_COUNT = 0;
+var MIN_MATCH_COUNT = 0;
+function containsHardcodedValues(xpath) {
+  const hardcodedNumbers = xpath.match(/\b[2-9]\d*\b/g);
+  if (hardcodedNumbers !== null && hardcodedNumbers.length > MIN_MATCH_COUNT) {
+    return true;
+  }
+  const hardcodedStrings = xpath.match(/["'][^"']*["']/g);
+  const hasLongHardcodedStrings = hardcodedStrings?.some(
+    (str) => str.length > MIN_HARDCODED_STRING_LENGTH
+  );
+  if (hasLongHardcodedStrings === true) {
+    return true;
+  }
+  return false;
+}
+function checkRuleMetadata(metadata) {
+  const errors = [];
+  const warnings = [];
+  if (metadata.ruleName === null || metadata.ruleName === void 0 || metadata.ruleName === "") {
+    errors.push("Rule name is missing");
+  }
+  if (metadata.message === null || metadata.message === void 0 || metadata.message === "") {
+    errors.push("Rule message is missing");
+  }
+  if (metadata.description === null || metadata.description === void 0 || metadata.description === "") {
+    warnings.push("Rule description is missing (recommended)");
+  }
+  if (metadata.xpath === null || metadata.xpath === void 0 || metadata.xpath === "") {
+    errors.push("Rule XPath expression is missing");
+  }
+  if (metadata.ruleName !== null && metadata.ruleName !== void 0 && metadata.ruleName.length < MIN_RULE_NAME_LENGTH) {
+    const minLengthStr = String(MIN_RULE_NAME_LENGTH);
+    warnings.push(
+      `Rule name is very short (less than ${minLengthStr} characters)`
+    );
+  }
+  if (metadata.message !== null && metadata.message !== void 0 && metadata.message.length < MIN_MESSAGE_LENGTH) {
+    const minLengthStr = String(MIN_MESSAGE_LENGTH);
+    warnings.push(
+      `Rule message is very short (less than ${minLengthStr} characters)`
+    );
+  }
+  if (metadata.description !== null && metadata.description !== void 0 && metadata.description.length < MIN_DESCRIPTION_LENGTH) {
+    const minLengthStr = String(MIN_DESCRIPTION_LENGTH);
+    warnings.push(
+      `Rule description is very short (less than ${minLengthStr} characters)`
+    );
+  }
+  const hasXPath = metadata.xpath !== null && metadata.xpath !== void 0 && metadata.xpath !== "";
+  if (hasXPath && containsHardcodedValues(metadata.xpath)) {
+    warnings.push(
+      "XPath contains hardcoded values that should be parameterized"
+    );
+  }
+  return {
+    issues: errors,
+    passed: errors.length === MIN_ERROR_COUNT,
+    warnings
+  };
+}
+
+// src/tester/quality/checkExamples.ts
+var MIN_EXAMPLES_COUNT = 0;
+var MIN_VIOLATION_MARKERS = 0;
+var MIN_VALID_MARKERS = 0;
+var MIN_VIOLATIONS = 0;
+var MIN_VALIDS = 0;
+var MIN_MARKERS = 0;
+var MIN_CODE_LINES = 0;
+var INDEX_OFFSET = 1;
+function checkMarkerConsistency(example, exampleNum, warnings) {
+  const totalMarkers = example.violationMarkers.length + example.validMarkers.length;
+  const totalCodeLines = example.violations.length + example.valids.length;
+  if (totalMarkers === MIN_MARKERS && totalCodeLines > MIN_CODE_LINES) {
+    const exampleNumStr = String(exampleNum);
+    warnings.push(`Example ${exampleNumStr} has code but no markers`);
+  }
+  if (totalMarkers > MIN_MARKERS && totalCodeLines === MIN_CODE_LINES) {
+    const exampleNumStr = String(exampleNum);
+    warnings.push(`Example ${exampleNumStr} has markers but no code`);
+  }
+}
+function checkExamples(examples) {
+  const errors = [];
+  const warnings = [];
+  if (examples.length === MIN_EXAMPLES_COUNT) {
+    errors.push("No examples found in rule");
+    return { issues: errors, passed: false, warnings };
+  }
+  examples.forEach(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameters for forEach
+    (example, index) => {
+      const exampleNum = index + INDEX_OFFSET;
+      if (example.violationMarkers.length === MIN_VIOLATION_MARKERS) {
+        const exampleNumStr = String(exampleNum);
+        warnings.push(
+          `Example ${exampleNumStr} has no violation markers`
+        );
+      }
+      if (example.validMarkers.length === MIN_VALID_MARKERS) {
+        const exampleNumStr = String(exampleNum);
+        warnings.push(`Example ${exampleNumStr} has no valid markers`);
+      }
+      if (example.violations.length === MIN_VIOLATIONS && example.valids.length === MIN_VALIDS) {
+        const exampleNumStr = String(exampleNum);
+        errors.push(`Example ${exampleNumStr} contains no code`);
+      }
+      const hasViolations = example.violations.length > MIN_VIOLATIONS;
+      const hasValids = example.valids.length > MIN_VALIDS;
+      if (hasViolations && hasValids && example.violationMarkers.length > MIN_VIOLATION_MARKERS && example.validMarkers.length > MIN_VALID_MARKERS) {
+      } else if (hasViolations && !hasValids) {
+        if (example.violationMarkers.length === MIN_VIOLATION_MARKERS) {
+          const exampleNumStr = String(exampleNum);
+          warnings.push(
+            `Example ${exampleNumStr} has violations but no violation markers`
+          );
+        }
+      } else if (!hasViolations && hasValids) {
+        if (example.validMarkers.length === MIN_VALID_MARKERS) {
+          const exampleNumStr = String(exampleNum);
+          warnings.push(
+            `Example ${exampleNumStr} has valid code but no valid markers`
+          );
+        }
+      }
+      checkMarkerConsistency(example, exampleNum, warnings);
+    }
+  );
+  const noErrors = errors.length === MIN_EXAMPLES_COUNT;
+  return {
+    issues: errors,
+    passed: noErrors,
+    warnings
+  };
+}
+
+// src/tester/quality/checkDuplicates.ts
+var MIN_EXAMPLES_FOR_DUPLICATE_CHECK = 2;
+var MIN_DUPLICATE_COUNT = 1;
+var MIN_PATTERN_LENGTH = 10;
+var PATTERN_DISPLAY_LENGTH = 50;
+var INDEX_OFFSET2 = 1;
+var ZERO_ERRORS = 0;
+var MIN_COUNT2 = 0;
+function normalizeCode(code) {
+  return code.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function checkPatternDuplicates(patterns, type, warnings) {
+  for (const [pattern, exampleNumbers] of patterns.entries()) {
+    if (exampleNumbers.length > MIN_DUPLICATE_COUNT && pattern.length > MIN_PATTERN_LENGTH) {
+      const patternPreview = pattern.substring(
+        MIN_COUNT2,
+        PATTERN_DISPLAY_LENGTH
+      );
+      warnings.push(
+        `Duplicate ${type} pattern "${patternPreview}..." found in examples: ${exampleNumbers.join(", ")}`
+      );
+    }
+  }
+}
+function checkDuplicates(examples) {
+  const errors = [];
+  const warnings = [];
+  if (examples.length < MIN_EXAMPLES_FOR_DUPLICATE_CHECK) {
+    return { issues: errors, passed: true, warnings };
+  }
+  const violationPatterns = /* @__PURE__ */ new Map();
+  const validPatterns = /* @__PURE__ */ new Map();
+  examples.forEach(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameters for forEach
+    (example, index) => {
+      const exampleNum = index + INDEX_OFFSET2;
+      example.violations.forEach((code) => {
+        const normalized = normalizeCode(code);
+        if (!violationPatterns.has(normalized)) {
+          violationPatterns.set(normalized, []);
+        }
+        const patternList = violationPatterns.get(normalized);
+        patternList.push(exampleNum);
+      });
+      example.valids.forEach((code) => {
+        const normalized = normalizeCode(code);
+        if (!validPatterns.has(normalized)) {
+          validPatterns.set(normalized, []);
+        }
+        const patternList = validPatterns.get(normalized);
+        patternList.push(exampleNum);
+      });
+    }
+  );
+  checkPatternDuplicates(violationPatterns, "violation", warnings);
+  checkPatternDuplicates(validPatterns, "valid", warnings);
+  const noErrors = errors.length === ZERO_ERRORS;
+  return {
+    issues: errors,
+    passed: noErrors,
+    warnings
+  };
+}
+
+// src/tester/qualityChecks.ts
+var MIN_ISSUES_COUNT = 0;
+function runQualityChecks(ruleMetadata, examples) {
+  const issues = [];
+  const warnings = [];
+  const metadataResult = checkRuleMetadata(ruleMetadata);
+  issues.push(...metadataResult.issues);
+  warnings.push(...metadataResult.warnings);
+  const examplesResult = checkExamples(examples);
+  issues.push(...examplesResult.issues);
+  warnings.push(...examplesResult.warnings);
+  const duplicatesResult = checkDuplicates(examples);
+  issues.push(...duplicatesResult.issues);
+  warnings.push(...duplicatesResult.warnings);
+  return {
+    issues,
+    passed: issues.length === MIN_ISSUES_COUNT,
+    warnings
+  };
+}
+
+// src/tester/RuleTester.ts
+var MIN_EXAMPLES_COUNT2 = 0;
+var MIN_VIOLATIONS_COUNT = 0;
+var EMPTY_STRING2 = "";
+var DEFAULT_CONCURRENCY = 1;
+function getAttributeValue(element, name) {
+  return element.getAttribute(name);
+}
+var RuleTester = class {
+  /**
+   * Creates a new RuleTester instance.
+   * @param ruleFilePath - Absolute or relative path to the PMD rule XML file.
+   * @throws {Error} If rule file does not exist or cannot be read.
+   */
+  constructor(ruleFilePath) {
+    if (!existsSync(ruleFilePath)) {
+      throw new Error(`Rule file not found: ${ruleFilePath}`);
+    }
+    if (!ruleFilePath.endsWith(".xml")) {
+      throw new Error("Rule file must have .xml extension");
+    }
+    this.ruleFilePath = ruleFilePath;
+    this.ruleMetadata = this.extractRuleMetadata();
+    this.ruleName = this.ruleMetadata.ruleName ?? "unknown";
+    this.category = this.extractCategory(ruleFilePath);
+    this.examples = [];
+    this.results = this.initializeResults();
+  }
+  /**
+   * Extract category from rule file path.
+   * @param ruleFilePath - Path to the rule file.
+   * @returns Category name.
+   * @private
+   */
+  extractCategory(ruleFilePath) {
+    void this.ruleFilePath;
+    const pathParts = ruleFilePath.split("/");
+    const rulesetsIndex = pathParts.findIndex(
+      (part) => part === "rulesets"
+    );
+    const minIndex = -1;
+    const categoryIndexOffset = 1;
+    if (rulesetsIndex !== minIndex && rulesetsIndex < pathParts.length - categoryIndexOffset) {
+      const categoryIndex = rulesetsIndex + categoryIndexOffset;
+      const category = pathParts[categoryIndex];
+      return category;
+    }
+    return "unknown";
+  }
+  /**
+   * Extracts rule metadata (name, message, description, XPath) from the rule XML file.
+   * @returns Parsed rule metadata object.
+   * @public
+   */
+  extractRuleMetadata() {
+    const content = readFileSync3(this.ruleFilePath, "utf-8");
+    const parser = new DOMParser3();
+    const doc = parser.parseFromString(content, "text/xml");
+    const ruleElement = doc.getElementsByTagName("rule")[MIN_EXAMPLES_COUNT2];
+    if (!ruleElement) {
+      return {
+        description: null,
+        message: null,
+        ruleName: null,
+        xpath: null
+      };
+    }
+    const ruleName = getAttributeValue(ruleElement, "name");
+    const message = getAttributeValue(ruleElement, "message");
+    const descriptionElements = ruleElement.getElementsByTagName("description");
+    let description = null;
+    if (descriptionElements.length > MIN_EXAMPLES_COUNT2) {
+      const descElement = descriptionElements[MIN_EXAMPLES_COUNT2];
+      const { textContent } = descElement;
+      if (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- textContent can be null at runtime
+        textContent !== null && textContent.trim() !== EMPTY_STRING2
+      ) {
+        description = textContent.trim();
+      }
+    }
+    const xpathResult = extractXPath(this.ruleFilePath);
+    let xpath = null;
+    if (xpathResult.success && xpathResult.data !== null && xpathResult.data !== void 0) {
+      xpath = xpathResult.data;
+    }
+    return { description, message, ruleName, xpath };
+  }
+  /**
+   * Extracts examples from the rule XML file.
+   * @returns Array of parsed example data.
+   * @public
+   */
+  extractExamples() {
+    const content = readFileSync3(this.ruleFilePath, "utf-8");
+    const parser = new DOMParser3();
+    const doc = parser.parseFromString(content, "text/xml");
+    const exampleNodes = doc.getElementsByTagName("example");
+    const extractedExamples = [];
+    const indexOffset = 1;
+    for (let i = 0; i < exampleNodes.length; i++) {
+      const exampleNode = exampleNodes[i];
+      const { textContent } = exampleNode;
+      const MIN_CONTENT_LENGTH = 0;
+      if (textContent.length === MIN_CONTENT_LENGTH) continue;
+      const exampleContent = textContent.trim();
+      if (exampleContent.length > MIN_CONTENT_LENGTH) {
+        const parsedExample = parseExample(exampleContent);
+        extractedExamples.push({
+          content: exampleContent,
+          exampleIndex: i + indexOffset,
+          validMarkers: parsedExample.validMarkers,
+          valids: parsedExample.valids,
+          violationMarkers: parsedExample.violationMarkers,
+          violations: parsedExample.violations
+        });
+      }
+    }
+    this.examples = extractedExamples;
+    return this.examples;
+  }
+  /**
+   * Gets the rule metadata.
+   * @returns Rule metadata object.
+   * @public
+   */
+  getRuleMetadata() {
+    return this.ruleMetadata;
+  }
+  /**
+   * Gets the extracted examples.
+   * @returns Array of parsed example data.
+   * @public
+   */
+  getExamples() {
+    return this.examples;
+  }
+  /**
+   * Cleans up temporary files created during testing.
+   * @public
+   */
+  cleanup() {
+    void this.ruleFilePath;
+  }
+  /**
+   * Runs comprehensive rule testing including PMD execution, quality checks, and XPath analysis.
+   * @param skipPMDValidation - Skip actual PMD validation (for testing).
+   * @param maxConcurrency - Maximum number of examples to test concurrently.
+   * @returns Promise resolving to complete test results.
+   * @public
+   */
+  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 ? (
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter for map
+      this.examples.map((_example, i) => ({
+        actualViolations: ZERO_VIOLATIONS,
+        exampleIndex: i + INDEX_OFFSET3,
+        expectedValids: ZERO_VIOLATIONS,
+        expectedViolations: ZERO_VIOLATIONS,
+        passed: true,
+        testCaseResults: []
+      }))
+    ) : await this.validateExamplesWithPMD(maxConcurrency);
+    this.results.examplesTested = this.examples.length;
+    this.results.examplesPassed = exampleResults.filter(
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter
+      (r) => r.passed
+    ).length;
+    this.results.totalViolations = exampleResults.reduce(
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameters
+      (sum, result) => sum + result.actualViolations,
+      MIN_VIOLATIONS_COUNT
+    );
+    this.results.ruleTriggersViolations = exampleResults.some(
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter
+      (result) => result.actualViolations > MIN_VIOLATIONS_COUNT
+    );
+    this.results.detailedTestResults = exampleResults.flatMap(
+      // 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.success = qualityResult.passed && this.examples.length > MIN_EXAMPLES_COUNT2 && this.results.examplesPassed === this.results.examplesTested;
+    return Promise.resolve(this.results);
+  }
+  /**
+   * Validates examples by actually running PMD and checking results.
+   * @param _maxConcurrency - Maximum number of examples to test concurrently.
+   * @returns Promise resolving to validation results for each example.
+   * @private
+   */
+  async validateExamplesWithPMD(_maxConcurrency = DEFAULT_CONCURRENCY) {
+    return this.validateExamplesWithPMDSequential();
+  }
+  /**
+   * Validates examples sequentially (original implementation for compatibility).
+   * @returns Promise resolving to validation results for each example.
+   * @private
+   */
+  async validateExamplesWithPMDSequential() {
+    const EXAMPLE_INDEX_OFFSET = 1;
+    const results = [];
+    for (let i = 0; i < this.examples.length; i++) {
+      const example = this.examples[i];
+      const exampleIndex = i + EXAMPLE_INDEX_OFFSET;
+      const testCaseResults = [];
+      let passed = true;
+      let actualViolations = 0;
+      const MIN_VIOLATIONS_LENGTH = 0;
+      if (example.violations.length > MIN_VIOLATIONS_LENGTH) {
+        const violationTestFile = createTestFile({
+          exampleContent: example.content,
+          exampleIndex,
+          includeValids: false,
+          includeViolations: true
+        });
+        const testPassed = await this.runTestCase({
+          exampleIndex,
+          filePath: violationTestFile.filePath,
+          testCaseResults,
+          testType: "violation"
+        });
+        if (!testPassed) {
+          passed = false;
+        }
+        try {
+          const pmdResult = await runPMD(
+            violationTestFile.filePath,
+            this.ruleFilePath
+          );
+          if (pmdResult.success && pmdResult.data) {
+            actualViolations += pmdResult.data.violations.length;
+          }
+        } catch {
+        }
+      }
+      const MIN_VALIDS_LENGTH = 0;
+      if (example.valids.length > MIN_VALIDS_LENGTH) {
+        const validTestFile = createTestFile({
+          exampleContent: example.content,
+          exampleIndex,
+          includeValids: true,
+          includeViolations: false
+        });
+        const testPassed = await this.runTestCase({
+          exampleIndex,
+          filePath: validTestFile.filePath,
+          testCaseResults,
+          testType: "valid"
+        });
+        if (!testPassed) {
+          passed = false;
+        }
+      }
+      results.push({
+        actualViolations,
+        exampleIndex,
+        expectedValids: example.valids.length,
+        expectedViolations: example.violations.length,
+        passed,
+        testCaseResults
+      });
+    }
+    return results;
+  }
+  /**
+   * Runs a single test case and records the result.
+   * @param testCaseConfig - Configuration for the test case.
+   * @param testCaseConfig.exampleIndex - 1-based index of the example being tested.
+   * @param testCaseConfig.filePath - Path to the temporary test file.
+   * @param testCaseConfig.testCaseResults - Array to append test case results to.
+   * @param testCaseConfig.testType - Type of test ('valid' or 'violation').
+   * @returns Promise resolving to whether the test passed.
+   * @private
+   */
+  async runTestCase(testCaseConfig) {
+    const { exampleIndex, filePath, testCaseResults, testType } = testCaseConfig;
+    try {
+      const pmdResult = await runPMD(filePath, this.ruleFilePath);
+      let passed = false;
+      let lineNumber = void 0;
+      const ZERO_VIOLATIONS_COUNT = 0;
+      if (pmdResult.success && pmdResult.data) {
+        if (testType === "violation") {
+          passed = pmdResult.data.violations.length > ZERO_VIOLATIONS_COUNT;
+          if (!passed) {
+            lineNumber = this.findTestCaseLineNumber(
+              exampleIndex,
+              testType
+            );
+          }
+        } else {
+          passed = pmdResult.data.violations.length === ZERO_VIOLATIONS_COUNT;
+          if (!passed) {
+            lineNumber = this.findTestCaseLineNumber(
+              exampleIndex,
+              testType
+            );
+          }
+        }
+      } else {
+        passed = false;
+        lineNumber = this.findTestCaseLineNumber(
+          exampleIndex,
+          testType
+        );
+      }
+      const testTypeLabel = testType === "violation" ? "Violation" : "Valid";
+      testCaseResults.push({
+        description: `${testTypeLabel} test for example ${String(exampleIndex)}`,
+        exampleIndex,
+        lineNumber,
+        passed,
+        testType
+      });
+      return passed;
+    } catch {
+      const lineNumber = this.findExampleLineNumber(exampleIndex);
+      const testTypeLabel = testType === "violation" ? "Violation" : "Valid";
+      testCaseResults.push({
+        description: `${testTypeLabel} test for example ${String(exampleIndex)}`,
+        exampleIndex,
+        lineNumber,
+        passed: false,
+        testType
+      });
+      return false;
+    }
+  }
+  /**
+   * Finds the line number in the XML file for a specific test case within an example.
+   * @param exampleIndex - 1-based example index.
+   * @param testType - Type of test case ('valid' or 'violation').
+   * @returns Line number in the XML file, or undefined if not found.
+   * @private
+   */
+  findTestCaseLineNumber(exampleIndex, testType) {
+    try {
+      const content = readFileSync3(this.ruleFilePath, "utf-8");
+      const lines = content.split("\n");
+      const NOT_FOUND_INDEX2 = -1;
+      let exampleStart = NOT_FOUND_INDEX2;
+      let exampleEnd = NOT_FOUND_INDEX2;
+      let currentExampleIndex = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes("<example>")) {
+          currentExampleIndex++;
+          exampleStart = currentExampleIndex === exampleIndex ? i : exampleStart;
+        } else if (line.includes("</example>") && currentExampleIndex === exampleIndex) {
+          exampleEnd = i;
+          break;
+        }
+      }
+      if (exampleStart === NOT_FOUND_INDEX2 || exampleEnd === NOT_FOUND_INDEX2) {
+        return void 0;
+      }
+      const hasInlineMarkers = () => {
+        for (let i = exampleStart; i <= exampleEnd; i++) {
+          const line = lines[i];
+          if (line.includes("// \u274C") || line.includes("// \u2705")) {
+            return true;
+          }
+        }
+        return false;
+      };
+      const LINE_NUMBER_OFFSET2 = 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;
+          }
+        } 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 nextLineRaw = lines[j];
+              const nextLine = nextLineRaw.trim();
+              if (nextLine && !nextLine.startsWith("//") && !nextLine.startsWith("*/") && !nextLine.startsWith("/*") && !nextLine.startsWith("</") && !nextLine.startsWith("<")) {
+                return j + LINE_NUMBER_OFFSET2;
+              }
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  /**
+   * Finds the line number in the XML file for a given example index.
+   * @param exampleIndex - 1-based example index.
+   * @returns Line number in the XML file, or undefined if not found.
+   * @private
+   */
+  findExampleLineNumber(exampleIndex) {
+    const content = readFileSync3(this.ruleFilePath, "utf-8");
+    const lines = content.split("\n");
+    let currentExampleIndex = 0;
+    const LINE_NUMBER_OFFSET2 = 1;
+    const NOT_FOUND_INDEX2 = -1;
+    const foundIndex = lines.findIndex((line) => {
+      if (line.includes("<example>")) {
+        currentExampleIndex++;
+        return currentExampleIndex === exampleIndex;
+      }
+      return false;
+    });
+    return foundIndex === NOT_FOUND_INDEX2 ? void 0 : foundIndex + LINE_NUMBER_OFFSET2;
+  }
+  /**
+   * Initializes an empty results object for a new test run.
+   * @returns Initialized OverallTestResults object.
+   * @private
+   */
+  initializeResults() {
+    void this.ruleFilePath;
+    return {
+      examplesPassed: MIN_EXAMPLES_COUNT2,
+      examplesTested: MIN_EXAMPLES_COUNT2,
+      hardcodedValues: [],
+      ruleTriggersViolations: false,
+      success: false,
+      testResults: [],
+      totalViolations: MIN_VIOLATIONS_COUNT,
+      xpathCoverage: {
+        coverage: [],
+        overallSuccess: false,
+        uncoveredBranches: []
+      }
+    };
+  }
+};
+
+// src/utils/concurrency.ts
+async function limitConcurrency(tasks, maxConcurrency) {
+  const results = new Array(tasks.length);
+  const executing = [];
+  let index = 0;
+  const executeNext = async () => {
+    const currentIndex = index++;
+    const task = tasks[currentIndex];
+    if (!task) {
+      return;
+    }
+    try {
+      results[currentIndex] = await task();
+    } catch (error) {
+      throw error;
+    }
+  };
+  for (let i = 0; i < Math.min(maxConcurrency, tasks.length); i++) {
+    executing.push(executeNext());
+  }
+  for (let i = 0; i < tasks.length; i++) {
+    if (i >= maxConcurrency) {
+      await executing[i % maxConcurrency];
+      executing[i % maxConcurrency] = executeNext();
+    }
+  }
+  await Promise.all(executing);
+  return results;
+}
+
+// src/coverage/trackCoverage.ts
+var CoverageTracker = class {
+  constructor(ruleFilePath) {
+    this.coverageData = {
+      componentLines: /* @__PURE__ */ new Map(),
+      filePath: ruleFilePath,
+      xpathLines: /* @__PURE__ */ new Map()
+    };
+  }
+  /**
+   * Records that an XPath line was executed.
+   * @param lineNumber - Line number in the XML file.
+   */
+  recordXPathLine(lineNumber) {
+    const INITIAL_COUNT = 0;
+    const INCREMENT = 1;
+    const current = this.coverageData.xpathLines.get(lineNumber) ?? INITIAL_COUNT;
+    this.coverageData.xpathLines.set(lineNumber, current + INCREMENT);
+  }
+  /**
+   * Records that an XPath component line was executed.
+   * @param lineNumber - Line number in the XML file.
+   */
+  recordComponentLine(lineNumber) {
+    const INITIAL_COUNT = 0;
+    const INCREMENT = 1;
+    const current = this.coverageData.componentLines.get(lineNumber) ?? INITIAL_COUNT;
+    this.coverageData.componentLines.set(lineNumber, current + INCREMENT);
+  }
+  /**
+   * Gets the coverage data.
+   * @returns Coverage data for this rule file.
+   */
+  getCoverageData() {
+    return this.coverageData;
+  }
+};
+
+// src/coverage/generateLcov.ts
+import { writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { dirname } from "path";
+function generateLcovReport(coverageData, outputPath) {
+  const lcovContent = [];
+  for (const data of coverageData) {
+    lcovContent.push(`SF:${data.filePath}`);
+    for (const [lineNumber, executionCount] of data.xpathLines) {
+      lcovContent.push(`DA:${String(lineNumber)},${String(executionCount)}`);
+    }
+    for (const [lineNumber, executionCount] of data.componentLines) {
+      lcovContent.push(`DA:${String(lineNumber)},${String(executionCount)}`);
+    }
+    lcovContent.push("end_of_record");
+  }
+  const outputDir = dirname(outputPath);
+  mkdirSync(outputDir, { recursive: true });
+  const content = lcovContent.join("\n") + "\n";
+  writeFileSync2(outputPath, content, "utf-8");
+}
+
+// src/cli/main.ts
+var EXIT_CODE_SUCCESS = 0;
+var EXIT_CODE_ERROR = 1;
+var ARGV_SLICE_INDEX = 2;
+var MIN_ARGS_COUNT = 0;
+var MAX_ARGS_COUNT = 2;
+var FIRST_ARG_INDEX = 0;
+var SECOND_ARG_INDEX = 1;
+var REPEAT_CHAR_COUNT = 60;
+var MIN_FAILED_FILES_COUNT = 0;
+function findXmlFiles(directory) {
+  const xmlFiles = [];
+  const items = readdirSync(directory);
+  for (const item of items) {
+    const fullPath = resolve3(directory, item);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      xmlFiles.push(...findXmlFiles(fullPath));
+    } else if (stat.isFile() && extname(fullPath).toLowerCase() === ".xml") {
+      xmlFiles.push(fullPath);
+    }
+  }
+  return xmlFiles;
+}
+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) {
+        coverageTracker.recordXPathLine(lineNumber);
+      }
+    }
+    console.log(
+      `
+\u{1F9EA} Testing rule: ${ruleFilePath}${coverageTracker ? " (with coverage)" : ""}
+`
+    );
+    const MIN_DETAILED_RESULTS_COUNT = 0;
+    if (result.detailedTestResults && result.detailedTestResults.length > MIN_DETAILED_RESULTS_COUNT) {
+      console.log("\u{1F4CB} Test Details:");
+      for (const testResult of result.detailedTestResults) {
+        const status = testResult.passed ? "\u2705" : "\u274C";
+        const testType = testResult.testType === "violation" ? "Violation" : "Valid";
+        const lineInfo = testResult.lineNumber !== void 0 ? ` Line: ${String(testResult.lineNumber)}` : "";
+        console.log(
+          `   - Example ${String(testResult.exampleIndex)} Test: ${testType} ${status}${lineInfo}`
+        );
+      }
+    }
+    const MIN_COUNT3 = 0;
+    const INDEX_OFFSET3 = 1;
+    if (result.success) {
+      console.log("\n\u{1F4CA} Test Summary:");
+      console.log(`  Examples tested: ${String(result.examplesTested)}`);
+      console.log(`  Examples passed: ${String(result.examplesPassed)}`);
+      console.log(
+        `  Total violations: ${String(result.totalViolations)}`
+      );
+      console.log(
+        `  Rule triggers violations: ${result.ruleTriggersViolations ? "\u2705 Yes" : "\u274C No"}`
+      );
+    }
+    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);
+    }
+    if (result.xpathCoverage.coverage.length > MIN_COUNT3) {
+      console.log(
+        `  Coverage items: ${String(result.xpathCoverage.coverage.length)}`
+      );
+      result.xpathCoverage.coverage.forEach(
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameters for forEach
+        (coverage, index) => {
+          const itemNumber = index + INDEX_OFFSET3;
+          const status = coverage.success ? "\u2705" : coverage.evidence.some(
+            // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter for some
+            (evidence) => evidence.count > MIN_COUNT3 && evidence.count < evidence.required
+          ) ? "\u26A0\uFE0F" : "\u274C";
+          console.log(
+            `    ${String(itemNumber)}. ${status} ${coverage.message}`
+          );
+          if (coverage.evidence.length > MIN_COUNT3) {
+            coverage.evidence.forEach(
+              // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameters for forEach
+              (evidence) => {
+                const { description } = evidence;
+                if (description.length > MIN_COUNT3) {
+                  if (description.includes("\n")) {
+                    description.split("\n").forEach(
+                      (line) => {
+                        console.log(
+                          `         ${line}`
+                        );
+                      }
+                    );
+                  } else {
+                    console.log(`         ${description}`);
+                  }
+                }
+              }
+            );
+          }
+        }
+      );
+    }
+    if (result.hardcodedValues.length > MIN_COUNT3) {
+      console.log(
+        `
+\u26A0\uFE0F  Hardcoded values found: ${String(result.hardcodedValues.length)}`
+      );
+      result.hardcodedValues.forEach(
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameters for forEach
+        (issue) => {
+          console.log(
+            `  - ${issue.type}: ${issue.value} (${issue.severity})`
+          );
+        }
+      );
+    }
+    const isCoverageIncomplete = !result.xpathCoverage.overallSuccess;
+    if (result.success && !isCoverageIncomplete) {
+      console.log("\n\u2705 All tests passed!");
+    } else if (isCoverageIncomplete) {
+      console.log("\n\u274C Tests failed, incomplete coverage");
+    }
+    tester.cleanup();
+    const coverageData = coverageTracker !== null ? coverageTracker.getCoverageData() : void 0;
+    return {
+      coverageData,
+      filePath: ruleFilePath,
+      success: result.success
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`
+\u274C Error testing ${ruleFilePath}: ${errorMessage}`);
+    return { error: errorMessage, filePath: ruleFilePath, success: false };
+  }
+}
+async function main() {
+  const args = argv.slice(ARGV_SLICE_INDEX);
+  if (args.length === MIN_ARGS_COUNT || args.length > MAX_ARGS_COUNT) {
+    console.log("Usage: test-pmd-rule <rule.xml|directory> [--coverage]");
+    console.log(
+      "\nThis tool tests PMD rules using examples embedded in XML rule files."
+    );
+    console.log("\nArguments:");
+    console.log(
+      "  <rule.xml|directory>  Path to XML rule file or directory containing XML files"
+    );
+    console.log(
+      "  --coverage             Generate LCOV coverage report in coverage/lcov.info"
+    );
+    console.log("\nRequirements:");
+    console.log("- PMD CLI installed and in PATH");
+    console.log("- Node.js 25+");
+    process.exit(EXIT_CODE_ERROR);
+  }
+  const pathArg = args[FIRST_ARG_INDEX];
+  if (typeof pathArg !== "string") {
+    console.error("\u274C Invalid path argument");
+    process.exit(EXIT_CODE_ERROR);
+  }
+  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);
+  }
+  const stat = statSync(pathArg);
+  const xmlFiles = [];
+  if (stat.isFile()) {
+    if (!pathArg.endsWith(".xml")) {
+      console.error("\u274C File must be an XML rule file (.xml)");
+      process.exit(EXIT_CODE_ERROR);
+    }
+    xmlFiles.push(pathArg);
+  } else if (stat.isDirectory()) {
+    xmlFiles.push(...findXmlFiles(pathArg));
+    const MIN_XML_FILES_COUNT = 0;
+    if (xmlFiles.length === MIN_XML_FILES_COUNT) {
+      console.error(`\u274C No XML files found in directory: ${pathArg}`);
+      process.exit(EXIT_CODE_ERROR);
+    }
+  } else {
+    console.error(`\u274C Path is neither a file nor directory: ${pathArg}`);
+    process.exit(EXIT_CODE_ERROR);
+  }
+  const cpuCount = cpus().length;
+  const maxFileConcurrency = Math.min(xmlFiles.length, cpuCount);
+  const maxExampleConcurrency = cpuCount;
+  console.log(
+    `
+\u{1F680} Processing ${String(xmlFiles.length)} rule file(s) with ${String(maxFileConcurrency)} parallel workers`
+  );
+  console.log(
+    `   Each file will test examples with up to ${String(maxExampleConcurrency)} parallel workers
+`
+  );
+  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) {
+        coverageTrackers.set(filePath, tracker);
+      }
+      return testRuleFile(filePath, tracker, maxExampleConcurrency);
+    }
+  );
+  const results = await limitConcurrency(tasks, maxFileConcurrency);
+  const successfulFiles = results.filter(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter
+    (r) => r.success
+  ).length;
+  const failedFiles = results.filter(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter
+    (r) => !r.success
+  ).length;
+  console.log("\n" + "=".repeat(REPEAT_CHAR_COUNT));
+  console.log("\u{1F3AF} OVERALL RESULTS");
+  console.log("=".repeat(REPEAT_CHAR_COUNT));
+  console.log(`Total files processed: ${String(xmlFiles.length)}`);
+  console.log(`Successful: ${String(successfulFiles)}`);
+  console.log(`Failed: ${String(failedFiles)}`);
+  if (failedFiles > MIN_FAILED_FILES_COUNT) {
+    console.log("\n\u274C Failed files:");
+    results.filter((r) => !r.success).forEach((result) => {
+      const errorMessage = result.error ?? "";
+      const MIN_ERROR_LENGTH = 0;
+      const errorSuffix = errorMessage.length > MIN_ERROR_LENGTH ? `: ${errorMessage}` : "";
+      console.log(`  - ${result.filePath}${errorSuffix}`);
+    });
+  }
+  if (hasCoverageFlag && coverageTrackers !== null) {
+    const coverageData = Array.from(
+      coverageTrackers.values()
+    ).map(
+      (tracker) => tracker.getCoverageData()
+    );
+    try {
+      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(
+        `
+\u274C Error generating coverage report: ${errorMessage}`
+      );
+      process.exit(EXIT_CODE_ERROR);
+    }
+  }
+  process.exit(
+    failedFiles === MIN_FAILED_FILES_COUNT ? EXIT_CODE_SUCCESS : EXIT_CODE_ERROR
+  );
+}
+process.on("uncaughtException", (error) => {
+  console.error(`Unexpected error: ${error.message}`);
+  process.exit(EXIT_CODE_ERROR);
+});
+process.on(
+  "unhandledRejection",
+  (_reason, _promise) => {
+    const reasonString = typeof _reason === "string" ? _reason : _reason instanceof Error ? _reason.message : JSON.stringify(_reason);
+    const promiseString = "[Promise]";
+    console.error(
+      `Unhandled Rejection at: ${promiseString}, reason: ${reasonString}`
+    );
+    process.exit(EXIT_CODE_ERROR);
+  }
+);
+main().catch((error) => {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  console.error(`Unexpected error: ${errorMessage}`);
+  process.exit(EXIT_CODE_ERROR);
+});
+//# sourceMappingURL=test-pmd-rule.js.map