eslint-plugin-traceability 1.6.4 → 1.7.0

package/lib/src/utils/reqAnnotationDetection.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasReqAnnotation = hasReqAnnotation;
+/**
+ * Shared @req detection helpers used by annotation-checker utilities.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQ-DETECTION - Detect @req markers around function-like nodes
+ */
+const require_story_io_1 = require("../rules/helpers/require-story-io");
+/**
+ * Predicate helper to check whether a comment contains a @req annotation.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQ-DETECTION - Detect @req tag inside a comment
+ */
+function commentContainsReq(c) {
+    return c && typeof c.value === "string" && c.value.includes("@req");
+}
+/**
+ * Line-based helper adapted from linesBeforeHasStory to detect @req.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQ-DETECTION - Detect @req in preceding source lines
+ */
+function linesBeforeHasReq(sourceCode, node) {
+    const lines = sourceCode && sourceCode.lines;
+    const startLine = node && node.loc && typeof node.loc.start?.line === "number"
+        ? node.loc.start.line
+        : null;
+    // Guard against missing or malformed source/loc information before scanning.
+    // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+    // @req REQ-ANNOTATION-REQ-DETECTION - Avoid false positives when sourceCode/loc is incomplete
+    if (!Array.isArray(lines) || typeof startLine !== "number") {
+        return false;
+    }
+    const from = Math.max(0, startLine - 1 - require_story_io_1.LOOKBACK_LINES);
+    const to = Math.max(0, startLine - 1);
+    // Scan each physical line in the configured lookback window for an @req marker.
+    // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+    // @req REQ-ANNOTATION-REQ-DETECTION - Search preceding lines for @req text
+    for (let i = from; i < to; i++) {
+        const text = lines[i];
+        // When a line contains @req we treat the function as already annotated.
+        // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+        // @req REQ-ANNOTATION-REQ-DETECTION - Detect @req marker in raw source lines
+        if (typeof text === "string" && text.includes("@req")) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Parent-chain helper adapted from parentChainHasStory to detect @req.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQ-DETECTION - Detect @req in parent-chain comments
+ */
+function parentChainHasReq(sourceCode, node) {
+    let p = node && node.parent;
+    // Walk up the parent chain and inspect comments attached to each ancestor.
+    // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+    // @req REQ-ANNOTATION-REQ-DETECTION - Traverse parent nodes when local comments are absent
+    while (p) {
+        const pComments = typeof sourceCode?.getCommentsBefore === "function"
+            ? sourceCode.getCommentsBefore(p) || []
+            : [];
+        // Look for @req in comments immediately preceding each parent node.
+        // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+        // @req REQ-ANNOTATION-REQ-DETECTION - Detect @req markers in parent comments
+        if (Array.isArray(pComments) && pComments.some(commentContainsReq)) {
+            return true;
+        }
+        const pLeading = p.leadingComments || [];
+        // Also inspect leadingComments attached directly to the parent node.
+        // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+        // @req REQ-ANNOTATION-REQ-DETECTION - Detect @req markers in parent leadingComments
+        if (Array.isArray(pLeading) && pLeading.some(commentContainsReq)) {
+            return true;
+        }
+        p = p.parent;
+    }
+    return false;
+}
+/**
+ * Fallback text window helper adapted from fallbackTextBeforeHasStory to detect @req.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQ-DETECTION - Detect @req in fallback text window before node
+ */
+function fallbackTextBeforeHasReq(sourceCode, node) {
+    // Guard against unsupported sourceCode or nodes without a usable range.
+    // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+    // @req REQ-ANNOTATION-REQ-DETECTION - Ensure we only inspect text when range information is available
+    if (typeof sourceCode?.getText !== "function" ||
+        !Array.isArray((node && node.range) || [])) {
+        return false;
+    }
+    const range = node.range;
+    // Guard when the node range cannot provide a numeric start index.
+    // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+    // @req REQ-ANNOTATION-REQ-DETECTION - Avoid scanning when range start is not a number
+    if (!Array.isArray(range) || typeof range[0] !== "number") {
+        return false;
+    }
+    try {
+        const start = Math.max(0, range[0] - require_story_io_1.FALLBACK_WINDOW);
+        const textBefore = sourceCode.getText().slice(start, range[0]);
+        // Detect @req in the bounded text window immediately preceding the node.
+        // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+        // @req REQ-ANNOTATION-REQ-DETECTION - Detect @req marker in fallback text window
+        if (typeof textBefore === "string" && textBefore.includes("@req")) {
+            return true;
+        }
+    }
+    catch {
+        // Swallow detection errors to avoid breaking lint runs due to malformed source.
+        // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+        // @req REQ-ANNOTATION-REQ-DETECTION - Treat IO/detection failures as "no annotation" instead of throwing
+        /* noop */
+    }
+    return false;
+}
+/**
+ * Helper to determine whether a JSDoc or any nearby comments contain a @req annotation.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQ-DETECTION - Determine presence of @req annotation
+ */
+function hasReqAnnotation(jsdoc, comments, context, node) {
+    try {
+        const sourceCode = context && typeof context.getSourceCode === "function"
+            ? context.getSourceCode()
+            : undefined;
+        // Prefer robust, location-based heuristics when sourceCode and node are available.
+        // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+        // @req REQ-ANNOTATION-REQ-DETECTION - Use multiple heuristics to detect @req markers around the node
+        if (sourceCode && node) {
+            if (linesBeforeHasReq(sourceCode, node) ||
+                parentChainHasReq(sourceCode, node) ||
+                fallbackTextBeforeHasReq(sourceCode, node)) {
+                return true;
+            }
+        }
+    }
+    catch {
+        // Swallow detection errors and fall through to simple checks.
+        // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+        // @req REQ-ANNOTATION-REQ-DETECTION - Fail gracefully when advanced detection heuristics throw
+    }
+    // BRANCH @req detection on JSDoc or comments
+    // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+    // @req REQ-ANNOTATION-REQ-DETECTION
+    return ((jsdoc &&
+        typeof jsdoc.value === "string" &&
+        jsdoc.value.includes("@req")) ||
+        comments.some(commentContainsReq));
+}

package/lib/tests/maintenance/cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/maintenance/cli.test.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Tests for: docs/stories/009.0-DEV-MAINTENANCE-TOOLS.story.md
+ * @story docs/stories/009.0-DEV-MAINTENANCE-TOOLS.story.md
+ * @req REQ-MAINT-DETECT - CLI detection of stale annotations
+ * @req REQ-MAINT-VERIFY - CLI verification of annotations
+ * @req REQ-MAINT-REPORT - CLI reporting of stale annotations
+ * @req REQ-MAINT-UPDATE - CLI updating of annotation references
+ * @req REQ-MAINT-SAFE - Clear exit codes and non-destructive dry-run
+ */
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../../src/maintenance/cli");
+function withTempDir() {
+    const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "maint-cli-"));
+    return tmpDir;
+}
+describe("Maintenance CLI (Story 009.0-DEV-MAINTENANCE-TOOLS)", () => {
+    let originalCwd;
+    beforeAll(() => {
+        originalCwd = process.cwd();
+    });
+    afterAll(() => {
+        process.chdir(originalCwd);
+    });
+    it("[REQ-MAINT-DETECT] detect exits with code 0 and message when no stale annotations", () => {
+        const dir = withTempDir();
+        process.chdir(dir);
+        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        const code = (0, cli_1.runMaintenanceCli)(["node", "traceability-maint", "detect"]);
+        try {
+            expect(code).toBe(0);
+            expect(logSpy).toHaveBeenCalledWith("No stale @story annotations found.");
+        }
+        finally {
+            logSpy.mockRestore();
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("[REQ-MAINT-VERIFY] verify exits with code 0 when annotations valid", () => {
+        const dir = withTempDir();
+        process.chdir(dir);
+        const tsContent = `/**\n * @story my-story.story.md\n */`;
+        fs_1.default.writeFileSync(path_1.default.join(dir, "file.ts"), tsContent, "utf8");
+        fs_1.default.writeFileSync(path_1.default.join(dir, "my-story.story.md"), "# Dummy Story", "utf8");
+        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        const code = (0, cli_1.runMaintenanceCli)(["node", "traceability-maint", "verify"]);
+        try {
+            expect(code).toBe(0);
+            expect(logSpy).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            logSpy.mockRestore();
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("[REQ-MAINT-REPORT] report prints human-readable summary and exits 0", () => {
+        const dir = withTempDir();
+        process.chdir(dir);
+        const tsContent = `/**\n * @story missing.story.md\n */`;
+        fs_1.default.writeFileSync(path_1.default.join(dir, "file.ts"), tsContent, "utf8");
+        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        const code = (0, cli_1.runMaintenanceCli)(["node", "traceability-maint", "report"]);
+        try {
+            expect(code).toBe(0);
+            const allMessages = logSpy.mock.calls.flat().join("\n");
+            expect(allMessages).toContain("Traceability Maintenance Report");
+            expect(allMessages).toContain("missing.story.md");
+        }
+        finally {
+            logSpy.mockRestore();
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("[REQ-MAINT-UPDATE] update performs replacements and exits 0", () => {
+        const dir = withTempDir();
+        process.chdir(dir);
+        const tsContent = `/**\n * @story old.path.md\n */`;
+        fs_1.default.writeFileSync(path_1.default.join(dir, "file.ts"), tsContent, "utf8");
+        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        const code = (0, cli_1.runMaintenanceCli)([
+            "node",
+            "traceability-maint",
+            "update",
+            "--from",
+            "old.path.md",
+            "--to",
+            "new.path.md",
+        ]);
+        try {
+            expect(code).toBe(0);
+            const updated = fs_1.default.readFileSync(path_1.default.join(dir, "file.ts"), "utf8");
+            expect(updated).toContain("@story new.path.md");
+        }
+        finally {
+            logSpy.mockRestore();
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("[REQ-MAINT-SAFE] update requires --from and --to and exits 2 when missing", () => {
+        const dir = withTempDir();
+        process.chdir(dir);
+        const errorSpy = jest.spyOn(console, "error").mockImplementation(() => { });
+        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        const code = (0, cli_1.runMaintenanceCli)(["node", "traceability-maint", "update"]);
+        try {
+            expect(code).toBe(2);
+            expect(errorSpy).toHaveBeenCalled();
+            expect(logSpy).toHaveBeenCalled();
+        }
+        finally {
+            errorSpy.mockRestore();
+            logSpy.mockRestore();
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("[REQ-MAINT-SAFE] dry-run does not modify files and exits 0", () => {
+        const dir = withTempDir();
+        process.chdir(dir);
+        const tsContent = `/**\n * @story old.path.md\n */`;
+        fs_1.default.writeFileSync(path_1.default.join(dir, "file.ts"), tsContent, "utf8");
+        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        const code = (0, cli_1.runMaintenanceCli)([
+            "node",
+            "traceability-maint",
+            "update",
+            "--from",
+            "old.path.md",
+            "--to",
+            "new.path.md",
+            "--dry-run",
+        ]);
+        try {
+            expect(code).toBe(0);
+            const contentAfter = fs_1.default.readFileSync(path_1.default.join(dir, "file.ts"), "utf8");
+            expect(contentAfter).toBe(tsContent);
+        }
+        finally {
+            logSpy.mockRestore();
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("[REQ-MAINT-DETECT] detect supports --json output", () => {
+        const dir = withTempDir();
+        process.chdir(dir);
+        const tsContent = `/**\n * @story stale.story.md\n */`;
+        fs_1.default.writeFileSync(path_1.default.join(dir, "file.ts"), tsContent, "utf8");
+        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        const code = (0, cli_1.runMaintenanceCli)([
+            "node",
+            "traceability-maint",
+            "detect",
+            "--json",
+        ]);
+        try {
+            expect(code).toBe(1);
+            expect(logSpy).toHaveBeenCalledTimes(1);
+            const payload = JSON.parse(String(logSpy.mock.calls[0][0]));
+            expect(Array.isArray(payload.stale)).toBe(true);
+            expect(payload.stale).toContain("stale.story.md");
+        }
+        finally {
+            logSpy.mockRestore();
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/lib/tests/maintenance/detect-isolated.test.js

@@ -38,10 +38,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @story docs/stories/009.0-DEV-MAINTENANCE-TOOLS.story.md
  * @req REQ-MAINT-DETECT - Detect stale annotation references
  */
-const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const detect_1 = require("../../src/maintenance/detect");
+const fs = require("fs");
 describe("detectStaleAnnotations isolated (Story 009.0-DEV-MAINTENANCE-TOOLS)", () => {
     it("[REQ-MAINT-DETECT] returns empty array when directory does not exist", () => {
         const result = (0, detect_1.detectStaleAnnotations)("non-existent-dir");
@@ -107,4 +107,71 @@ describe("detectStaleAnnotations isolated (Story 009.0-DEV-MAINTENANCE-TOOLS)",
             }
         }
     });
+    /**
+     * [REQ-MAINT-DETECT]
+     * Ensure detectStaleAnnotations performs security validation for unsafe
+     * and invalid-extension story paths and does not perform filesystem checks
+     * for malicious @story paths that escape the workspace
+     * (Story 009.0-DEV-MAINTENANCE-TOOLS).
+     */
+    it("[REQ-MAINT-DETECT] performs security validation for unsafe and invalid-extension story paths without stat'ing outside workspace", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tmp-workspace-"));
+        const maliciousRelative = "../outside-project.story.md";
+        const maliciousAbsolute = "/etc/passwd.story.md";
+        const traversalInside = "nested/../inside.story.md";
+        const invalidExtension = "invalid.txt";
+        const filePath = path.join(tmpDir, "file.ts");
+        const content = `
+/**
+ * @story ${maliciousRelative}
+ * @story ${maliciousAbsolute}
+ * @story ${traversalInside}
+ * @story ${invalidExtension}
+ * @story legitimate.story.md
+ */
+`;
+        fs.writeFileSync(filePath, content, "utf8");
+        const existsCalls = [];
+        const originalExistsSync = fs.existsSync;
+        const existsSpy = jest
+            .spyOn(fs, "existsSync")
+            .mockImplementation((p) => {
+            const strPath = typeof p === "string" ? p : p.toString();
+            existsCalls.push(strPath);
+            return originalExistsSync(p);
+        });
+        try {
+            (0, detect_1.detectStaleAnnotations)(tmpDir);
+            const allPathsChecked = [...existsCalls];
+            // Ensure no raw malicious values were checked
+            expect(allPathsChecked).not.toContain(maliciousRelative);
+            expect(allPathsChecked).not.toContain(maliciousAbsolute);
+            expect(allPathsChecked).not.toContain(invalidExtension);
+            // Also ensure no resolved variants of these paths were checked
+            const resolvedRelative = path.resolve(tmpDir, maliciousRelative);
+            const resolvedAbsolute = path.resolve(maliciousAbsolute);
+            const resolvedInvalid = path.resolve(tmpDir, invalidExtension);
+            expect(allPathsChecked).not.toContain(resolvedRelative);
+            expect(allPathsChecked).not.toContain(resolvedAbsolute);
+            expect(allPathsChecked).not.toContain(resolvedInvalid);
+            expect(allPathsChecked.some((p) => p.includes("outside-project.story.md"))).toBe(false);
+            expect(allPathsChecked.some((p) => p.includes("passwd.story.md"))).toBe(false);
+            expect(allPathsChecked.some((p) => p.includes("invalid.txt"))).toBe(false);
+            // traversalInside normalizes within workspace and should be checked
+            const resolvedTraversalInside = path.resolve(tmpDir, traversalInside);
+            expect(allPathsChecked).toContain(resolvedTraversalInside);
+            // legitimate in-workspace .story.md path should also be checked
+            const resolvedLegit = path.resolve(tmpDir, "legitimate.story.md");
+            expect(allPathsChecked).toContain(resolvedLegit);
+        }
+        finally {
+            existsSpy.mockRestore();
+            try {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+    });
 });

package/lib/tests/maintenance/report.test.js

@@ -58,10 +58,10 @@ describe("generateMaintenanceReport (Story 009.0-DEV-MAINTENANCE-TOOLS)", () =>
     it("[REQ-MAINT-REPORT] should report stale story annotation", () => {
         const filePath = path.join(tmpDir, "stub.md");
         const content = `/**
- * @story non-existent.md
+ * @story non-existent.story.md
  */`;
         fs.writeFileSync(filePath, content);
         const report = (0, report_1.generateMaintenanceReport)(tmpDir);
-        expect(report).toContain("non-existent.md");
+        expect(report).toContain("non-existent.story.md");
     });
 });

package/lib/tests/rules/require-branch-annotation.test.js

@@ -17,8 +17,9 @@ const require_branch_annotation_1 = __importDefault(require("../../src/rules/req
 const ruleTester = new eslint_1.RuleTester({
     languageOptions: { parserOptions: { ecmaVersion: 2020 } },
 });
+const runRule = (tests) => ruleTester.run("require-branch-annotation", require_branch_annotation_1.default, tests);
 describe("Require Branch Annotation Rule (Story 004.0-DEV-BRANCH-ANNOTATIONS)", () => {
-    ruleTester.run("require-branch-annotation", require_branch_annotation_1.default, {
+    runRule({
         valid: [
             {
                 name: "[REQ-BRANCH-DETECTION] valid fallback scanning comment detection",
@@ -277,7 +278,7 @@ for (let i = 0; i < 3; i++) {}`,
             },
         ],
     });
-    ruleTester.run("require-branch-annotation", require_branch_annotation_1.default, {
+    runRule({
         valid: [],
         invalid: [
             {

package/lib/tests/rules/require-req-annotation.test.js

@@ -9,14 +9,63 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @req REQ-ANNOTATION-REQUIRED - Verify require-req-annotation rule enforces @req on functions
  * @story docs/stories/007.0-DEV-ERROR-REPORTING.story.md
  * @req REQ-ERROR-SPECIFIC - Verify enhanced, specific error messaging behavior
+ *
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-TYPESCRIPT-SUPPORT - Verify TypeScript declarations are checked via shared annotation checker helper
  */
 const eslint_1 = require("eslint");
 const require_req_annotation_1 = __importDefault(require("../../src/rules/require-req-annotation"));
+const ts_language_options_1 = require("../utils/ts-language-options");
+const annotation_checker_test_1 = require("../utils/annotation-checker.test");
 const ruleTester = new eslint_1.RuleTester({
     languageOptions: {
         parserOptions: { ecmaVersion: 2022, sourceType: "module" },
     },
 });
+/**
+ * @trace Story 003.0-DEV-FUNCTION-ANNOTATIONS / REQ-TYPESCRIPT-SUPPORT
+ * Exercise the require-req-annotation rule's behavior on TSDeclareFunction and
+ * TSMethodSignature via the shared runAnnotationCheckerTests helper.
+ *
+ * The helper delegates to the real rule's TypeScript-specific visitors
+ * without changing its behavior; it provides the common TS parser
+ * configuration and assertion plumbing.
+ */
+(0, annotation_checker_test_1.runAnnotationCheckerTests)("require-req-annotation", {
+    rule: require_req_annotation_1.default,
+    valid: [
+        {
+            name: "[REQ-TYPESCRIPT-SUPPORT] valid with @req annotation on TSDeclareFunction",
+            code: `/**\n * @req REQ-EXAMPLE\n */\ndeclare function foo(): void;`,
+        },
+        {
+            name: "[REQ-TYPESCRIPT-SUPPORT] valid with @req annotation on TSMethodSignature",
+            code: `interface I {\n  /**\n   * @req REQ-EXAMPLE\n   */\n  method(): void;\n}`,
+        },
+    ],
+    invalid: [
+        {
+            name: "[REQ-TYPESCRIPT-SUPPORT] missing @req on TSDeclareFunction",
+            code: `declare function baz(): void;`,
+            errors: [
+                {
+                    messageId: "missingReq",
+                    data: { name: "baz", functionName: "baz" },
+                },
+            ],
+        },
+        {
+            name: "[REQ-TYPESCRIPT-SUPPORT] missing @req on TSMethodSignature",
+            code: `interface I { method(): void; }`,
+            errors: [
+                {
+                    messageId: "missingReq",
+                    data: { name: "method", functionName: "method" },
+                },
+            ],
+        },
+    ],
+});
 describe("Require Req Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", () => {
     ruleTester.run("require-req-annotation", require_req_annotation_1.default, {
         valid: [
@@ -28,22 +77,6 @@ describe("Require Req Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", (
                 name: "[REQ-ANNOTATION-REQUIRED] valid with @story and @req annotations",
                 code: `/**\n * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md\n * @req REQ-EXAMPLE\n */\nfunction bar() {}`,
             },
-            {
-                name: "[REQ-TYPESCRIPT-SUPPORT] valid with @req annotation on TSDeclareFunction",
-                code: `/**\n * @req REQ-EXAMPLE\n */\ndeclare function foo(): void;`,
-                languageOptions: {
-                    parser: require("@typescript-eslint/parser"),
-                    parserOptions: { ecmaVersion: 2022, sourceType: "module" },
-                },
-            },
-            {
-                name: "[REQ-TYPESCRIPT-SUPPORT] valid with @req annotation on TSMethodSignature",
-                code: `interface I {\n  /**\n   * @req REQ-EXAMPLE\n   */\n  method(): void;\n}`,
-                languageOptions: {
-                    parser: require("@typescript-eslint/parser"),
-                    parserOptions: { ecmaVersion: 2022, sourceType: "module" },
-                },
-            },
             {
                 name: "[REQ-FUNCTION-DETECTION][Story 003.0] valid FunctionExpression with @req annotation",
                 code: `const fn = /**\n * @req REQ-EXAMPLE\n */\nfunction() {};`,
@@ -52,22 +85,14 @@ describe("Require Req Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", (
                 name: "[REQ-FUNCTION-DETECTION][Story 003.0] valid MethodDefinition with @req annotation",
                 code: `class C {\n  /**\n   * @req REQ-EXAMPLE\n   */\n  m() {}\n}`,
             },
-            {
+            (0, ts_language_options_1.withTsLanguageOptions)({
                 name: "[REQ-TYPESCRIPT-SUPPORT][REQ-FUNCTION-DETECTION][Story 003.0] valid TS FunctionExpression in variable declarator with @req",
                 code: `const fn = /**\n * @req REQ-EXAMPLE\n */\nfunction () {};`,
-                languageOptions: {
-                    parser: require("@typescript-eslint/parser"),
-                    parserOptions: { ecmaVersion: 2022, sourceType: "module" },
-                },
-            },
-            {
+            }),
+            (0, ts_language_options_1.withTsLanguageOptions)({
                 name: "[REQ-TYPESCRIPT-SUPPORT][REQ-FUNCTION-DETECTION][Story 003.0] valid exported TS FunctionExpression in variable declarator with @req",
                 code: `export const fn = /**\n * @req REQ-EXAMPLE\n */\nfunction () {};`,
-                languageOptions: {
-                    parser: require("@typescript-eslint/parser"),
-                    parserOptions: { ecmaVersion: 2022, sourceType: "module" },
-                },
-            },
+            }),
             {
                 name: "[REQ-CONFIGURABLE-SCOPE][Story 003.0] FunctionExpression ignored when scope only includes FunctionDeclaration",
                 code: `const fn = function () {};`,
@@ -125,34 +150,6 @@ describe("Require Req Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", (
                     },
                 ],
             },
-            {
-                name: "[REQ-TYPESCRIPT-SUPPORT] missing @req on TSDeclareFunction",
-                code: `declare function baz(): void;`,
-                errors: [
-                    {
-                        messageId: "missingReq",
-                        data: { name: "baz", functionName: "baz" },
-                    },
-                ],
-                languageOptions: {
-                    parser: require("@typescript-eslint/parser"),
-                    parserOptions: { ecmaVersion: 2022, sourceType: "module" },
-                },
-            },
-            {
-                name: "[REQ-TYPESCRIPT-SUPPORT] missing @req on TSMethodSignature",
-                code: `interface I { method(): void; }`,
-                errors: [
-                    {
-                        messageId: "missingReq",
-                        data: { name: "method", functionName: "method" },
-                    },
-                ],
-                languageOptions: {
-                    parser: require("@typescript-eslint/parser"),
-                    parserOptions: { ecmaVersion: 2022, sourceType: "module" },
-                },
-            },
             {
                 name: "[REQ-FUNCTION-DETECTION][Story 003.0] missing @req on FunctionExpression assigned to variable",
                 code: `const fn = function () {};`,
@@ -193,7 +190,7 @@ describe("Require Req Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", (
                     },
                 ],
             },
-            {
+            (0, ts_language_options_1.withTsLanguageOptions)({
                 name: "[REQ-TYPESCRIPT-SUPPORT][REQ-FUNCTION-DETECTION][Story 003.0] missing @req on TS FunctionExpression in variable declarator",
                 code: `const fn = function () {};`,
                 errors: [
@@ -202,12 +199,8 @@ describe("Require Req Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", (
                         data: { name: "fn", functionName: "fn" },
                     },
                 ],
-                languageOptions: {
-                    parser: require("@typescript-eslint/parser"),
-                    parserOptions: { ecmaVersion: 2022, sourceType: "module" },
-                },
-            },
-            {
+            }),
+            (0, ts_language_options_1.withTsLanguageOptions)({
                 name: "[REQ-TYPESCRIPT-SUPPORT][REQ-FUNCTION-DETECTION][Story 003.0] missing @req on exported TS FunctionExpression in variable declarator",
                 code: `export const fn = function () {};`,
                 errors: [
@@ -216,11 +209,7 @@ describe("Require Req Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", (
                         data: { name: "fn", functionName: "fn" },
                     },
                 ],
-                languageOptions: {
-                    parser: require("@typescript-eslint/parser"),
-                    parserOptions: { ecmaVersion: 2022, sourceType: "module" },
-                },
-            },
+            }),
             {
                 name: "[REQ-CONFIGURABLE-SCOPE][Story 003.0] FunctionDeclaration still reported when scope only includes FunctionDeclaration",
                 code: `function scoped() {}`,