eslint-plugin-traceability 1.12.0 → 1.13.0

package/lib/src/utils/annotation-scope-analyzer.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPECTED_RANGE_LENGTH = void 0;
+exports.toStoryReqKey = toStoryReqKey;
+exports.extractStoryReqPairsFromText = extractStoryReqPairsFromText;
+exports.extractStoryReqPairsFromComments = extractStoryReqPairsFromComments;
+exports.arePairsFullyCovered = arePairsFullyCovered;
+exports.isStatementEligibleForRedundancy = isStatementEligibleForRedundancy;
+exports.getCommentRemovalRange = getCommentRemovalRange;
+/**
+ * Shared types and helpers for redundant-annotation detection.
+ *
+ * These utilities focus on parsing traceability annotations from comment
+ * text and computing relationships between "scope" coverage and
+ * statement-level annotations. They are intentionally small, pure
+ * functions so that the ESLint rule can delegate most of its logic
+ * here while keeping its own create/visitor code shallow.
+ *
+ * @supports docs/stories/027.0-DEV-REDUNDANT-ANNOTATION-DETECTION.story.md REQ-SCOPE-ANALYSIS REQ-DUPLICATION-DETECTION
+ */
+exports.EXPECTED_RANGE_LENGTH = 2; // [start, end]
+/**
+ * Build a canonical key for a story/requirement pair.
+ *
+ * Empty story or requirement components are normalized to the empty
+ * string so that comparisons remain stable even when some annotations
+ * omit one side (for example, malformed or story-less @req lines).
+ *
+ * @supports docs/stories/027.0-DEV-REDUNDANT-ANNOTATION-DETECTION.story.md REQ-DUPLICATION-DETECTION REQ-DIFFERENT-REQUIREMENTS
+ */
+function toStoryReqKey(storyPath, reqId) {
+    const story = storyPath ?? "";
+    const req = reqId ?? "";
+    return `${story}|${req}`;
+}
+/**
+ * Extract story/requirement pairs from a snippet of comment text.
+ *
+ * Supported patterns:
+ * - `@story <path>` followed by one or more `@req <ID>` lines.
+ * - `@supports <path> <REQ-ID-1> <REQ-ID-2> ...` where each `REQ-*`
+ *   token is treated as a separate pair bound to the same story path.
+ *
+ * The parser is intentionally conservative: it only creates pairs when
+ * it can confidently associate a requirement identifier with a story
+ * path. This avoids false positives in REQ-DIFFERENT-REQUIREMENTS by
+ * ensuring we never conflate different requirement IDs.
+ *
+ * @supports docs/stories/027.0-DEV-REDUNDANT-ANNOTATION-DETECTION.story.md REQ-SCOPE-ANALYSIS REQ-DUPLICATION-DETECTION REQ-DIFFERENT-REQUIREMENTS
+ */
+function extractStoryReqPairsFromText(text) {
+    const pairs = new Set();
+    if (!text)
+        return pairs;
+    const lines = text.split(/\r?\n/);
+    let currentStory = null;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        // @supports docs/stories/027.0-DEV-REDUNDANT-ANNOTATION-DETECTION.story.md REQ-SCOPE-ANALYSIS
+        const storyMatch = line.match(/@story\s+(\S+)/);
+        if (storyMatch) {
+            currentStory = storyMatch[1];
+        }
+        // Handle explicit @req lines that follow the most recent @story.
+        const reqMatch = line.match(/@req\s+(\S+)/);
+        if (reqMatch && currentStory) {
+            pairs.add(toStoryReqKey(currentStory, reqMatch[1]));
+        }
+        // Handle consolidated @supports lines that encode both story and
+        // requirement identifiers on a single line.
+        const supportsMatch = line.match(/@supports\s+(\S+)\s+(.+)/);
+        if (supportsMatch) {
+            const storyPath = supportsMatch[1];
+            const tail = supportsMatch[2];
+            const tokens = tail
+                .split(/\s+/)
+                .filter((t) => /^REQ-[A-Z0-9-]+$/.test(t));
+            for (const reqId of tokens) {
+                pairs.add(toStoryReqKey(storyPath, reqId));
+            }
+        }
+    }
+    return pairs;
+}
+/**
+ * Extract story/requirement pairs from a list of ESLint comment nodes.
+ *
+ * @supports docs/stories/027.0-DEV-REDUNDANT-ANNOTATION-DETECTION.story.md REQ-SCOPE-ANALYSIS REQ-DUPLICATION-DETECTION
+ */
+function extractStoryReqPairsFromComments(comments) {
+    const pairs = new Set();
+    if (!Array.isArray(comments) || comments.length === 0) {
+        return pairs;
+    }
+    const combinedText = comments
+        .filter((comment) => comment && typeof comment.value === "string")
+        .map((comment) => comment.value)
+        .join("\n");
+    const fromComments = extractStoryReqPairsFromText(combinedText);
+    for (const key of fromComments) {
+        pairs.add(key);
+    }
+    return pairs;
+}
+/**
+ * Determine whether all story/requirement pairs in `child` are already
+ * covered by `parent`.
+ *
+ * This implements the core notion of redundancy: if a statement-level
+ * annotation only repeats the exact same story+requirement pairs that
+ * are already declared on its containing scope, it does not add any
+ * new traceability information.
+ *
+ * @supports docs/stories/027.0-DEV-REDUNDANT-ANNOTATION-DETECTION.story.md REQ-DUPLICATION-DETECTION REQ-DIFFERENT-REQUIREMENTS REQ-SCOPE-INHERITANCE
+ */
+function arePairsFullyCovered(child, parent) {
+    if (child.size === 0)
+        return false;
+    if (parent.size === 0)
+        return false;
+    for (const key of child) {
+        if (!parent.has(key)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Decide whether a given statement node type should be considered
+ * "simple" or "significant" for redundancy detection, based on the
+ * configured strictness and alwaysCovered lists.
+ *
+ * - In `strict` mode, all non-branch statements are eligible.
+ * - In `moderate` mode (default), only statement types listed in
+ *   `alwaysCovered` plus bare expression statements are treated as
+ *   candidates for redundancy.
+ * - In `permissive` mode, only `alwaysCovered` types are considered.
+ *
+ * This keeps REQ-STATEMENT-SIGNIFICANCE and REQ-CONFIGURABLE-STRICTNESS
+ * aligned with the story's configuration model.
+ *
+ * @supports docs/stories/027.0-DEV-REDUNDANT-ANNOTATION-DETECTION.story.md REQ-STATEMENT-SIGNIFICANCE REQ-CONFIGURABLE-STRICTNESS
+ */
+function isStatementEligibleForRedundancy(node, options, branchTypes) {
+    if (!node || typeof node.type !== "string") {
+        return false;
+    }
+    // Never treat branch nodes themselves as "simple" statements; their
+    // annotations are typically intentional and should be preserved.
+    if (branchTypes.includes(node.type)) {
+        return false;
+    }
+    const alwaysCoveredSet = new Set(options.alwaysCovered);
+    if (alwaysCoveredSet.has(node.type)) {
+        return true;
+    }
+    if (options.strictness === "permissive") {
+        return false;
+    }
+    if (options.strictness === "moderate") {
+        // Treat side-effecting expression statements (e.g. assignments or
+        // simple calls) as eligible while still excluding more complex
+        // control-flow constructs.
+        return node.type === "ExpressionStatement";
+    }
+    // strict: any non-branch statement may be considered.
+    return true;
+}
+/**
+ * Compute the character range that should be removed when auto-fixing a
+ * redundant annotation comment.
+ *
+ * The implementation is conservative to satisfy REQ-SAFE-REMOVAL:
+ *
+ * - When the comment occupies its own line (only whitespace before the
+ *   comment token), the removal range is expanded to include that
+ *   leading whitespace and the trailing newline, so the entire line is
+ *   removed.
+ * - When there is other code before the comment on the same line, only
+ *   the comment text itself is removed, leaving surrounding code and
+ *   whitespace intact.
+ *
+ * @supports docs/stories/027.0-DEV-REDUNDANT-ANNOTATION-DETECTION.story.md REQ-SAFE-REMOVAL
+ */
+function getCommentRemovalRange(comment, sourceCode) {
+    const fullText = sourceCode.getText();
+    const range = comment && comment.range;
+    if (!Array.isArray(range) || range.length !== exports.EXPECTED_RANGE_LENGTH) {
+        return [0, 0];
+    }
+    let [start, end] = range;
+    // Find the start of the current line.
+    let lineStart = start;
+    while (lineStart > 0) {
+        const ch = fullText.charAt(lineStart - 1);
+        if (ch === "\n" || ch === "\r")
+            break;
+        lineStart -= 1;
+    }
+    const leadingText = fullText.slice(lineStart, start);
+    const onlyWhitespaceBeforeComment = leadingText.trim().length === 0;
+    let removalStart = start;
+    let removalEnd = end;
+    if (onlyWhitespaceBeforeComment) {
+        removalStart = lineStart;
+    }
+    // Expand to consume trailing whitespace after the comment.
+    while (removalEnd < fullText.length) {
+        const ch = fullText.charAt(removalEnd);
+        if (ch === " " || ch === "	") {
+            removalEnd += 1;
+        }
+        else {
+            break;
+        }
+    }
+    // Optionally include the newline when the comment owns the line.
+    if (onlyWhitespaceBeforeComment && removalEnd < fullText.length) {
+        const ch = fullText.charAt(removalEnd);
+        if (ch === "\r") {
+            removalEnd += 1;
+            if (fullText.charAt(removalEnd) === "\n") {
+                removalEnd += 1;
+            }
+        }
+        else if (ch === "\n") {
+            removalEnd += 1;
+        }
+    }
+    return [removalStart, removalEnd];
+}

package/lib/src/utils/branch-annotation-helpers.js

@@ -87,24 +87,69 @@ function extractCommentValue(_c) {
     return _c.value;
 }
 /**
- * Collect a single contiguous comment line at the given index, appending its
- * trimmed text to the accumulator. Returns true when a valid comment was
- * collected and false when scanning should stop (blank or non-comment line).
+ * Extract trimmed comment text for a given source line index or return null
+ * when the line is blank or not a comment. This helper centralizes the
+ * formatter-aware rules used by branch helpers when scanning for contiguous
+ * comment lines around branches.
  * @supports docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md REQ-COMMENT-ASSOCIATION
  * @supports docs/stories/025.0-DEV-CATCH-ANNOTATION-POSITION.story.md REQ-DUAL-POSITION-DETECTION REQ-FALLBACK-LOGIC
  * @supports docs/stories/026.0-DEV-ELSE-IF-ANNOTATION-POSITION.story.md REQ-DUAL-POSITION-DETECTION-ELSE-IF REQ-FALLBACK-LOGIC-ELSE-IF
  */
-function collectCommentLine(lines, index, comments) {
+function getCommentTextAtLine(lines, index) {
     const line = lines[index];
     if (!line || !line.trim()) {
-        return false;
+        return null;
     }
     if (!/^\s*(\/\/|\/\*)/.test(line)) {
+        return null;
+    }
+    return line.trim();
+}
+/**
+ * Collect a single contiguous comment line at the given index, appending its
+ * trimmed text to the accumulator. Returns true when a valid comment was
+ * collected and false when scanning should stop (blank or non-comment line).
+ * @supports docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md REQ-COMMENT-ASSOCIATION
+ * @supports docs/stories/025.0-DEV-CATCH-ANNOTATION-POSITION.story.md REQ-DUAL-POSITION-DETECTION REQ-FALLBACK-LOGIC
+ * @supports docs/stories/026.0-DEV-ELSE-IF-ANNOTATION-POSITION.story.md REQ-DUAL-POSITION-DETECTION-ELSE-IF REQ-FALLBACK-LOGIC-ELSE-IF
+ */
+function collectCommentLine(lines, index, comments) {
+    const commentText = getCommentTextAtLine(lines, index);
+    if (!commentText) {
         return false;
     }
-    comments.push(line.trim());
+    comments.push(commentText);
     return true;
 }
+/**
+ * Scan contiguous formatter-aware comment lines between the provided 0-based
+ * start and end indices (inclusive), stopping when a non-comment or blank line
+ * is encountered. This helper is used as a line-based fallback when
+ * structured comment APIs are not available for branch bodies.
+ * @supports docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md REQ-COMMENT-ASSOCIATION
+ * @supports docs/stories/025.0-DEV-CATCH-ANNOTATION-POSITION.story.md REQ-FALLBACK-LOGIC
+ * @supports docs/stories/026.0-DEV-ELSE-IF-ANNOTATION-POSITION.story.md REQ-FALLBACK-LOGIC-ELSE-IF
+ */
+function scanCommentLinesInRange(lines, startIndex, endIndexInclusive) {
+    if (!Array.isArray(lines) || lines.length === 0) {
+        return "";
+    }
+    if (startIndex < 0 ||
+        startIndex >= lines.length ||
+        startIndex > endIndexInclusive) {
+        return "";
+    }
+    const comments = [];
+    const lastIndex = Math.min(endIndexInclusive, lines.length - 1);
+    let i = startIndex;
+    while (i <= lastIndex) {
+        if (!collectCommentLine(lines, i, comments)) {
+            break;
+        }
+        i++;
+    }
+    return comments.join(" ");
+}
 function isElseIfBranch(node, parent) {
     return (node &&
         node.type === "IfStatement" &&
@@ -139,15 +184,7 @@ function gatherCatchClauseCommentText(sourceCode, node, beforeText) {
         const lines = sourceCode.lines;
         const startIndex = node.body.loc.start.line - 1;
         const endIndex = node.body.loc.end.line - 1;
-        const comments = [];
-        let i = startIndex + 1;
-        while (i <= endIndex) {
-            if (!collectCommentLine(lines, i, comments)) {
-                break;
-            }
-            i++;
-        }
-        const insideText = comments.join(" ");
+        const insideText = scanCommentLinesInRange(lines, startIndex + 1, endIndex);
         if (insideText) {
             return insideText;
         }
@@ -165,14 +202,11 @@ function scanElseIfPrecedingComments(sourceCode, node) {
     let i = startLine - 1;
     let scanned = 0;
     while (i >= 0 && scanned < PRE_COMMENT_OFFSET) {
-        const line = lines[i];
-        if (!line || !line.trim()) {
+        const commentText = getCommentTextAtLine(lines, i);
+        if (!commentText) {
             break;
         }
-        if (!/^\s*(\/\/|\/\*)/.test(line)) {
-            break;
-        }
-        comments.unshift(line.trim());
+        comments.unshift(commentText);
         i--;
         scanned++;
     }
@@ -194,13 +228,16 @@ function scanElseIfBetweenConditionAndBody(sourceCode, node) {
     const lines = sourceCode.lines;
     const conditionEndLine = node.test.loc.end.line;
     const consequentStartLine = node.consequent.loc.start.line;
-    const comments = [];
-    for (let lineIndex = conditionEndLine; lineIndex < consequentStartLine - 1; lineIndex++) {
-        if (!collectCommentLine(lines, lineIndex, comments)) {
-            break;
-        }
+    // Lines in sourceCode are 0-based indexes, but loc.line values are 1-based.
+    // We want to scan comments strictly between the condition and the
+    // consequent body, so we start at the line after the condition's end and
+    // stop at the line immediately before the consequent's starting line.
+    const startIndex = conditionEndLine; // already the next logical line index when 0-based
+    const endIndexExclusive = consequentStartLine - 1;
+    if (endIndexExclusive <= startIndex) {
+        return "";
     }
-    return comments.join(" ");
+    return scanCommentLinesInRange(lines, startIndex, endIndexExclusive - 1);
 }
 /** @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md */
 function scanElseIfInsideBlockComments(sourceCode, node) {
@@ -228,7 +265,10 @@ function scanElseIfInsideBlockComments(sourceCode, node) {
  * @supports REQ-FALLBACK-LOGIC
  */
 function gatherElseIfCommentText(sourceCode, node, parent, beforeText) {
-    if (/@story\b/.test(beforeText) || /@req\b/.test(beforeText)) {
+    if (beforeText &&
+        (/@story\b/.test(beforeText) ||
+            /@req\b/.test(beforeText) ||
+            /@supports\b/.test(beforeText))) {
         return beforeText;
     }
     if (!isElseIfBranch(node, parent)) {
@@ -236,7 +276,9 @@ function gatherElseIfCommentText(sourceCode, node, parent, beforeText) {
     }
     const beforeElseText = scanElseIfPrecedingComments(sourceCode, node);
     if (beforeElseText &&
-        (/@story\b/.test(beforeElseText) || /@req\b/.test(beforeElseText))) {
+        (/@story\b/.test(beforeElseText) ||
+            /@req\b/.test(beforeElseText) ||
+            /@supports\b/.test(beforeElseText))) {
         return beforeElseText;
     }
     if (!hasValidElseIfBlockLoc(node)) {
@@ -375,12 +417,28 @@ function reportMissingReq(context, node, options) {
  * @supports REQ-ANNOTATION-PARSING
  * @supports REQ-DUAL-POSITION-DETECTION
  */
-function getBaseBranchIndentAndInsertPos(sourceCode, node) {
-    let indent = sourceCode.lines[node.loc.start.line - 1].match(/^(\s*)/)?.[1] || "";
-    let insertPos = sourceCode.getIndexFromLoc({
-        line: node.loc.start.line,
+/**
+ * Compute indentation and insert position for the start of a given 1-based line
+ * number. This keeps indentation and fixer insert positions consistent across
+ * branch helpers that need to align auto-inserted comments with existing
+ * source formatting.
+ * @supports docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md REQ-ANNOTATION-PARSING
+ */
+function getIndentAndInsertPosForLine(sourceCode, line, fallbackIndent) {
+    const lines = sourceCode.lines;
+    let indent = fallbackIndent;
+    if (line >= 1 && line <= lines.length) {
+        const rawLine = lines[line - 1];
+        indent = rawLine.match(/^(\s*)/)?.[1] || fallbackIndent;
+    }
+    const insertPos = sourceCode.getIndexFromLoc({
+        line,
         column: 0,
     });
+    return { indent, insertPos };
+}
+function getBaseBranchIndentAndInsertPos(sourceCode, node) {
+    let { indent, insertPos } = getIndentAndInsertPosForLine(sourceCode, node.loc.start.line, "");
     if (node.type === "CatchClause" && node.body) {
         const bodyNode = node.body;
         const bodyStatements = Array.isArray(bodyNode.body)
@@ -391,22 +449,16 @@ function getBaseBranchIndentAndInsertPos(sourceCode, node) {
             : undefined;
         if (firstStatement && firstStatement.loc && firstStatement.loc.start) {
             const firstLine = firstStatement.loc.start.line;
-            const innerIndent = sourceCode.lines[firstLine - 1].match(/^(\s*)/)?.[1] || "";
-            indent = innerIndent;
-            insertPos = sourceCode.getIndexFromLoc({
-                line: firstLine,
-                column: 0,
-            });
+            const firstLineInfo = getIndentAndInsertPosForLine(sourceCode, firstLine, "");
+            indent = firstLineInfo.indent;
+            insertPos = firstLineInfo.insertPos;
         }
         else if (bodyNode.loc && bodyNode.loc.start) {
             const blockLine = bodyNode.loc.start.line;
-            const blockIndent = sourceCode.lines[blockLine - 1].match(/^(\s*)/)?.[1] || "";
-            const innerIndent = `${blockIndent}  `;
+            const blockLineInfo = getIndentAndInsertPosForLine(sourceCode, blockLine, "");
+            const innerIndent = `${blockLineInfo.indent}  `;
             indent = innerIndent;
-            insertPos = sourceCode.getIndexFromLoc({
-                line: blockLine,
-                column: 0,
-            });
+            insertPos = blockLineInfo.insertPos;
         }
     }
     return { indent, insertPos };
@@ -433,12 +485,9 @@ function getBranchAnnotationInfo(sourceCode, node, parent) {
         // For else-if blocks, align auto-fix comments with Prettier's tendency to place comments
         // inside the wrapped block body; non-block consequents intentionally keep the default behavior.
         const commentLine = node.consequent.loc.start.line + 1;
-        const commentIndent = sourceCode.lines[commentLine - 1]?.match(/^(\s*)/)?.[1] || indent;
-        indent = commentIndent;
-        insertPos = sourceCode.getIndexFromLoc({
-            line: commentLine,
-            column: 0,
-        });
+        const commentLineInfo = getIndentAndInsertPosForLine(sourceCode, commentLine, indent);
+        indent = commentLineInfo.indent;
+        insertPos = commentLineInfo.insertPos;
     }
     return { missingStory, missingReq, indent, insertPos };
 }

package/lib/tests/integration/dogfooding-validation.test.js

@@ -35,10 +35,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Dogfooding validation integration tests
- * @supports docs/stories/023.0-MAINT-DOGFOODING-VALIDATION.story.md REQ-DOGFOODING-TEST REQ-DOGFOODING-CI
+ * @supports docs/stories/023.0-MAINT-DOGFOODING-VALIDATION.story.md REQ-DOGFOODING-TEST REQ-DOGFOODING-CI REQ-DOGFOODING-VERIFY REQ-DOGFOODING-PRESET
  */
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const use_at_your_own_risk_1 = require("eslint/use-at-your-own-risk");
+const index_1 = __importStar(require("../../src/index"));
 /**
  * @supports docs/stories/023.0-MAINT-DOGFOODING-VALIDATION.story.md REQ-DOGFOODING-TEST
  */
@@ -91,4 +93,34 @@ describe("Dogfooding Validation (Story 023.0-MAINT-DOGFOODING-VALIDATION)", () =
         expect(result.stdout).toContain("error");
         expect(result.stdout).toContain("src/dogfood.ts");
     });
+    it("[REQ-DOGFOODING-VERIFY] should report at least one traceability rule active for TS sources", () => {
+        /**
+         * @supports docs/stories/023.0-MAINT-DOGFOODING-VALIDATION.story.md REQ-DOGFOODING-VERIFY
+         */
+        const eslintConfig = require("../../eslint.config.js");
+        const tsConfig = getTsConfigFromEslintConfig(eslintConfig);
+        expect(tsConfig).toBeDefined();
+        const rules = tsConfig.rules || {};
+        const hasTraceabilityRule = Object.keys(rules).some((key) => key.startsWith("traceability/"));
+        expect(hasTraceabilityRule).toBe(true);
+    });
+    it("[REQ-DOGFOODING-PRESET] should be compatible with recommended preset usage without throwing", async () => {
+        /**
+         * @supports docs/stories/023.0-MAINT-DOGFOODING-VALIDATION.story.md REQ-DOGFOODING-PRESET
+         */
+        const config = [
+            { plugins: { traceability: index_1.default }, rules: {} },
+            ...index_1.configs.recommended,
+        ];
+        const eslint = new use_at_your_own_risk_1.FlatESLint({
+            overrideConfig: config,
+            overrideConfigFile: true,
+            ignore: false,
+        });
+        const results = await eslint.lintText("function foo() {}", {
+            filePath: "example.ts",
+        });
+        expect(results.length).toBeGreaterThanOrEqual(1);
+        expect(Array.isArray(results[0].messages)).toBe(true);
+    });
 });

package/lib/tests/integration/else-if-annotation-prettier.integration.test.js

@@ -50,9 +50,8 @@ describe("Else-if annotations with Prettier (Story 026.0-DEV-ELSE-IF-ANNOTATION-
         }
         return result.stdout;
     }
-    if (process.env.TRACEABILITY_EXPERIMENTAL_ELSE_IF === "1") {
-        it("[REQ-PRETTIER-COMPATIBILITY-ELSE-IF-BEFORE] accepts code where annotations start before else-if but are moved between condition and body by Prettier", () => {
-            const original = `
+    it("[REQ-PRETTIER-COMPATIBILITY-ELSE-IF-BEFORE] accepts code where annotations start before else-if but are moved between condition and body by Prettier", () => {
+        const original = `
 function doA() {
   return 1;
 }
@@ -72,16 +71,16 @@ else if (anotherVeryLongConditionThatForcesWrapping && someOtherCondition) {
   doB();
 }
 `;
-            const formatted = formatWithPrettier(original);
-            // Sanity checks: Prettier should keep both the else-if branch and the associated story annotation,
-            // but the exact layout and comment movement may vary between versions.
-            expect(formatted).toContain("else if");
-            expect(formatted).toContain("@story docs/stories/026.0-DEV-ELSE-IF-ANNOTATION-POSITION.story.md");
-            const result = runEslintWithRequireBranchAnnotation(formatted);
-            expect(result.status).toBe(0);
-        });
-        it("[REQ-PRETTIER-COMPATIBILITY-ELSE-IF-INSIDE] accepts code where annotations start between condition and body and are preserved by Prettier", () => {
-            const original = `
+        const formatted = formatWithPrettier(original);
+        // Sanity checks: Prettier should keep both the else-if branch and the associated story annotation,
+        // but the exact layout and comment movement may vary between versions.
+        expect(formatted).toContain("else if");
+        expect(formatted).toContain("@story docs/stories/026.0-DEV-ELSE-IF-ANNOTATION-POSITION.story.md");
+        const result = runEslintWithRequireBranchAnnotation(formatted);
+        expect(result.status).toBe(0);
+    });
+    it("[REQ-PRETTIER-COMPATIBILITY-ELSE-IF-INSIDE] accepts code where annotations start between condition and body and are preserved by Prettier", () => {
+        const original = `
 function doA() {
   return 1;
 }
@@ -102,70 +101,10 @@ if (aVeryLongConditionThatForcesPrettierToWrapTheElseIfBranch && anotherConditio
   doB();
 }
 `;
-            const formatted = formatWithPrettier(original);
-            // Note: Prettier's exact layout of the else-if and its comments may differ between versions;
-            // the rule should accept any of the supported annotation positions regardless of formatting.
-            const result = runEslintWithRequireBranchAnnotation(formatted);
-            expect(result.status).toBe(0);
-        });
-    }
-    else {
-        it.skip("[REQ-PRETTIER-COMPATIBILITY-ELSE-IF-BEFORE] accepts code where annotations start before else-if but are moved between condition and body by Prettier", () => {
-            const original = `
-function doA() {
-  return 1;
-}
-
-function doB() {
-  return 2;
-}
-
-// @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
-// @req REQ-BRANCH-DETECTION
-if (aVeryLongConditionThatForcesPrettierToWrapTheElseIfBranch && anotherCondition) {
-  doA();
-}
-// @story docs/stories/026.0-DEV-ELSE-IF-ANNOTATION-POSITION.story.md
-// @req REQ-DUAL-POSITION-DETECTION-ELSE-IF
-else if (anotherVeryLongConditionThatForcesWrapping && someOtherCondition) {
-  doB();
-}
-`;
-            const formatted = formatWithPrettier(original);
-            // Sanity checks: Prettier should keep both the else-if branch and the associated story annotation,
-            // but the exact layout and comment movement may vary between versions.
-            expect(formatted).toContain("else if");
-            expect(formatted).toContain("@story docs/stories/026.0-DEV-ELSE-IF-ANNOTATION-POSITION.story.md");
-            const result = runEslintWithRequireBranchAnnotation(formatted);
-            expect(result.status).toBe(0);
-        });
-        it.skip("[REQ-PRETTIER-COMPATIBILITY-ELSE-IF-INSIDE] accepts code where annotations start between condition and body and are preserved by Prettier", () => {
-            const original = `
-function doA() {
-  return 1;
-}
-
-function doB() {
-  return 2;
-}
-
-// @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
-// @req REQ-BRANCH-DETECTION
-if (aVeryLongConditionThatForcesPrettierToWrapTheElseIfBranch && anotherCondition) {
-  doA();
-} else if (
-  anotherVeryLongConditionThatForcesWrapping && someOtherCondition
-) {
-  // @story docs/stories/026.0-DEV-ELSE-IF-ANNOTATION-POSITION.story.md
-  // @req REQ-DUAL-POSITION-DETECTION-ELSE-IF
-  doB();
-}
-`;
-            const formatted = formatWithPrettier(original);
-            // Note: Prettier's exact layout of the else-if and its comments may differ between versions;
-            // the rule should accept any of the supported annotation positions regardless of formatting.
-            const result = runEslintWithRequireBranchAnnotation(formatted);
-            expect(result.status).toBe(0);
-        });
-    }
+        const formatted = formatWithPrettier(original);
+        // Note: Prettier's exact layout of the else-if and its comments may differ between versions;
+        // the rule should accept any of the supported annotation positions regardless of formatting.
+        const result = runEslintWithRequireBranchAnnotation(formatted);
+        expect(result.status).toBe(0);
+    });
 });

package/lib/tests/plugin-default-export-and-configs.test.js

@@ -59,6 +59,7 @@ describe("Plugin Default Export and Configs (Story 001.0-DEV-PLUGIN-SETUP)", ()
             "valid-req-reference",
             "prefer-implements-annotation",
             "require-test-traceability",
+            "no-redundant-annotation",
             "prefer-supports-annotation",
         ];
         // Act: get actual rule names from plugin