eslint-plugin-traceability 1.1.8 → 1.1.9

package/lib/src/rules/require-branch-annotation.d.ts

@@ -1,4 +1,4 @@
-/**
+/****
  * Rule to enforce @story and @req annotations on significant code branches
  * @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
  * @req REQ-BRANCH-DETECTION - Detect significant code branches for traceability annotations

package/lib/src/rules/require-branch-annotation.js

@@ -1,23 +1,17 @@
 "use strict";
-/**
+/****
  * Rule to enforce @story and @req annotations on significant code branches
  * @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
  * @req REQ-BRANCH-DETECTION - Detect significant code branches for traceability annotations
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Helper to check a branch AST node for traceability annotations.
+ * Gather leading comments for a node, with fallback for SwitchCase.
  * @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
- * @req REQ-BRANCH-DETECTION - Helper for branch annotation detection
+ * @req REQ-BRANCH-DETECTION - Gather comments including fallback scanning
  */
-function checkBranchNode(sourceCode, context, node) {
-    // Skip default switch cases during annotation checks
-    if (node.type === "SwitchCase" && node.test == null) {
-        return;
-    }
-    let comments = sourceCode.getCommentsBefore(node) || [];
-    // Fallback scanning for SwitchCase when no leading comment nodes
-    if (node.type === "SwitchCase" && comments.length === 0) {
+function gatherCommentText(sourceCode, node) {
+    if (node.type === "SwitchCase") {
         const lines = sourceCode.lines;
         const startLine = node.loc.start.line;
         let i = startLine - 1;
@@ -35,9 +29,18 @@ function checkBranchNode(sourceCode, context, node) {
                 break;
             }
         }
-        comments = fallbackComments.map((text) => ({ value: text }));
+        return fallbackComments.join(" ");
     }
-    const text = comments.map((c) => c.value).join(" ");
+    const comments = sourceCode.getCommentsBefore(node) || [];
+    return comments.map((c) => c.value).join(" ");
+}
+/**
+ * Helper to check a branch AST node for traceability annotations.
+ * @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
+ * @req REQ-BRANCH-DETECTION - Helper for branch annotation detection
+ */
+function checkBranchNode(sourceCode, context, node) {
+    const text = gatherCommentText(sourceCode, node);
     const missingStory = !/@story\b/.test(text);
     const missingReq = !/@req\b/.test(text);
     if (missingStory) {
@@ -92,7 +95,12 @@ exports.default = {
         const sourceCode = context.getSourceCode();
         return {
             IfStatement: (node) => checkBranchNode(sourceCode, context, node),
-            SwitchCase: (node) => checkBranchNode(sourceCode, context, node),
+            SwitchCase: (node) => {
+                if (node.test === null) {
+                    return;
+                }
+                return checkBranchNode(sourceCode, context, node);
+            },
             TryStatement: (node) => checkBranchNode(sourceCode, context, node),
             CatchClause: (node) => checkBranchNode(sourceCode, context, node),
             ForStatement: (node) => checkBranchNode(sourceCode, context, node),

package/lib/src/rules/require-story-annotation.d.ts

@@ -1,7 +1,10 @@
 /**
- * Rule to enforce @story annotation on functions
+ * Rule to enforce @story annotation on functions, function expressions, arrow functions, and methods
  * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
  * @req REQ-ANNOTATION-REQUIRED - Require @story annotation on functions
+ * @req REQ-OPTIONS-SCOPE - Support configuring which function types to enforce via options
+ * @req REQ-EXPORT-PRIORITY - Add exportPriority option to target exported or non-exported
+ * @req REQ-UNIFIED-CHECK - Implement unified checkNode for all supported node types
  */
 declare const _default: any;
 export default _default;

package/lib/src/rules/require-story-annotation.js

@@ -1,49 +1,201 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Rule to enforce @story annotation on functions
+ * Rule to enforce @story annotation on functions, function expressions, arrow functions, and methods
  * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
  * @req REQ-ANNOTATION-REQUIRED - Require @story annotation on functions
+ * @req REQ-OPTIONS-SCOPE - Support configuring which function types to enforce via options
+ * @req REQ-EXPORT-PRIORITY - Add exportPriority option to target exported or non-exported
+ * @req REQ-UNIFIED-CHECK - Implement unified checkNode for all supported node types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Determine if a node is exported via export declaration.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-EXPORT-PRIORITY - Determine if function node has export declaration ancestor
+ */
+function isExportedNode(node) {
+    let current = node;
+    while (current) {
+        if (current.type === "ExportNamedDeclaration" ||
+            current.type === "ExportDefaultDeclaration") {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Find nearest ancestor node of specified types.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-OPTIONS-SCOPE - Support configuring which function types to enforce via options
+ */
+function findAncestorNode(node, types) {
+    let current = node.parent;
+    while (current) {
+        if (types.includes(current.type)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * Determine if node should be checked based on scope and exportPriority.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-OPTIONS-SCOPE
+ * @req REQ-EXPORT-PRIORITY
+ * @req REQ-UNIFIED-CHECK
+ */
+function shouldCheckNode(node, scope, exportPriority) {
+    if (node.type === "FunctionExpression" &&
+        node.parent?.type === "MethodDefinition") {
+        return false;
+    }
+    if (!scope.includes(node.type)) {
+        return false;
+    }
+    const exported = isExportedNode(node);
+    if ((exportPriority === "exported" && !exported) ||
+        (exportPriority === "non-exported" && exported)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Resolve the AST node to annotate or check.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-UNIFIED-CHECK
  */
+function resolveTargetNode(sourceCode, node) {
+    let target = node;
+    if (node.type === "FunctionDeclaration") {
+        const exp = findAncestorNode(node, [
+            "ExportNamedDeclaration",
+            "ExportDefaultDeclaration",
+        ]);
+        if (exp) {
+            target = exp;
+        }
+    }
+    else if (node.type === "FunctionExpression" ||
+        node.type === "ArrowFunctionExpression") {
+        const exp = findAncestorNode(node, [
+            "ExportNamedDeclaration",
+            "ExportDefaultDeclaration",
+        ]);
+        if (exp) {
+            target = exp;
+        }
+        else {
+            const anc = findAncestorNode(node, [
+                "VariableDeclaration",
+                "ExpressionStatement",
+            ]);
+            if (anc) {
+                target = anc;
+            }
+        }
+    }
+    else if (node.type === "MethodDefinition") {
+        target = node;
+    }
+    return target;
+}
+/**
+ * Check if the target node has @story annotation.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQUIRED
+ */
+function hasStoryAnnotation(sourceCode, target) {
+    const jsdoc = sourceCode.getJSDocComment(target);
+    if (jsdoc?.value.includes("@story")) {
+        return true;
+    }
+    const comments = sourceCode.getCommentsBefore(target) || [];
+    return comments.some((c) => c.value.includes("@story"));
+}
+/**
+ * Check for @story annotation on function-like nodes.
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-UNIFIED-CHECK
+ * @req REQ-ANNOTATION-REQUIRED
+ */
+function checkStoryAnnotation(sourceCode, context, node, scope, exportPriority) {
+    if (!shouldCheckNode(node, scope, exportPriority)) {
+        return;
+    }
+    const target = resolveTargetNode(sourceCode, node);
+    if (hasStoryAnnotation(sourceCode, target)) {
+        return;
+    }
+    context.report({
+        node,
+        messageId: "missingStory",
+        fix(fixer) {
+            const indentLevel = target.loc.start.column;
+            const indent = " ".repeat(indentLevel);
+            const insertPos = target.range[0] - indentLevel;
+            return fixer.insertTextBeforeRange([insertPos, insertPos], `${indent}/** @story <story-file>.story.md */\n`);
+        },
+    });
+}
 exports.default = {
     meta: {
         type: "problem",
         docs: {
-            description: "Require @story annotations on functions",
+            description: "Require @story annotations on selected functions",
             recommended: "error",
         },
         fixable: "code",
         messages: {
-            missingStory: "Missing @story annotation",
+            missingStory: "Missing @story annotation (REQ-ANNOTATION-REQUIRED)",
         },
-        schema: [],
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    scope: {
+                        type: "array",
+                        items: {
+                            enum: [
+                                "FunctionDeclaration",
+                                "FunctionExpression",
+                                "ArrowFunctionExpression",
+                                "MethodDefinition",
+                            ],
+                        },
+                        uniqueItems: true,
+                    },
+                    exportPriority: {
+                        enum: ["all", "exported", "non-exported"],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
     },
     create(context) {
         const sourceCode = context.getSourceCode();
+        const options = context.options[0] || {};
+        const scope = options.scope || [
+            "FunctionDeclaration",
+            "FunctionExpression",
+            "ArrowFunctionExpression",
+            "MethodDefinition",
+        ];
+        const exportPriority = options.exportPriority || "all";
         return {
             FunctionDeclaration(node) {
-                const jsdoc = sourceCode.getJSDocComment(node);
-                let hasStory = false;
-                // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
-                // @req REQ-JSDOC-PARSING - Detect JSDoc @story annotation presence
-                if (jsdoc && jsdoc.value.includes("@story")) {
-                    hasStory = true;
-                    // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
-                    // @req REQ-JSDOC-PARSING - Fallback to loading comments before node for @story annotation detection
-                }
-                else {
-                    const commentsBefore = sourceCode.getCommentsBefore(node) || [];
-                    hasStory = commentsBefore.some((comment) => comment.value.includes("@story"));
-                }
-                if (!hasStory) {
-                    context.report({
-                        node,
-                        messageId: "missingStory",
-                        fix(fixer) {
-                            return fixer.insertTextBefore(node, "/** @story <story-file>.story.md */\n");
-                        },
-                    });
-                }
+                checkStoryAnnotation(sourceCode, context, node, scope, exportPriority);
+            },
+            FunctionExpression(node) {
+                checkStoryAnnotation(sourceCode, context, node, scope, exportPriority);
+            },
+            ArrowFunctionExpression(node) {
+                checkStoryAnnotation(sourceCode, context, node, scope, exportPriority);
+            },
+            MethodDefinition(node) {
+                checkStoryAnnotation(sourceCode, context, node, scope, exportPriority);
             },
         };
     },

package/lib/src/rules/valid-req-reference.js

@@ -15,14 +15,122 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 /**
- * Create the Program listener for validating @req annotations.
- * @story docs/stories/010.0-DEV-DEEP-VALIDATION.story.md
- * @req REQ-DEEP-PARSE - Parse story files to extract requirement identifiers
- * @req REQ-DEEP-MATCH - Validate @req references against story file content
- * @req REQ-DEEP-CACHE - Cache parsed story content for performance
- * @req REQ-DEEP-PATH - Protect against path traversal in story paths
+ * Extract the story path from a JSDoc comment.
+ * Parses comment.value lines for @story annotation.
+ * @param comment any JSDoc comment node
+ * @returns story path or null if not found
+ */
+function extractStoryPath(comment) {
+    const rawLines = comment.value.split(/\r?\n/);
+    for (const rawLine of rawLines) {
+        const line = rawLine.trim().replace(/^\*+\s*/, "");
+        if (line.startsWith("@story")) {
+            const parts = line.split(/\s+/);
+            return parts[1] || null;
+        }
+    }
+    return null;
+}
+/**
+ * Validate a @req annotation line against the extracted story content.
+ * Performs path validation, file reading, caching, and requirement existence checks.
+ * @param comment any JSDoc comment node
+ * @param context ESLint rule context
+ * @param line the @req annotation line
+ * @param storyPath current story path
+ * @param cwd current working directory
+ * @param reqCache cache mapping story paths to sets of requirement IDs
+ */
+function validateReqLine(comment, context, line, storyPath, cwd, reqCache) {
+    const parts = line.split(/\s+/);
+    const reqId = parts[1];
+    if (!reqId || !storyPath) {
+        return;
+    }
+    if (storyPath.includes("..") || path_1.default.isAbsolute(storyPath)) {
+        context.report({
+            node: comment,
+            messageId: "invalidPath",
+            data: { storyPath },
+        });
+        return;
+    }
+    const resolvedStoryPath = path_1.default.resolve(cwd, storyPath);
+    if (!resolvedStoryPath.startsWith(cwd + path_1.default.sep) &&
+        resolvedStoryPath !== cwd) {
+        context.report({
+            node: comment,
+            messageId: "invalidPath",
+            data: { storyPath },
+        });
+        return;
+    }
+    if (!reqCache.has(resolvedStoryPath)) {
+        try {
+            const content = fs_1.default.readFileSync(resolvedStoryPath, "utf8");
+            const found = new Set();
+            const regex = /REQ-[A-Z0-9-]+/g;
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                found.add(match[0]);
+            }
+            reqCache.set(resolvedStoryPath, found);
+        }
+        catch {
+            reqCache.set(resolvedStoryPath, new Set());
+        }
+    }
+    const reqSet = reqCache.get(resolvedStoryPath);
+    if (!reqSet.has(reqId)) {
+        context.report({
+            node: comment,
+            messageId: "reqMissing",
+            data: { reqId, storyPath },
+        });
+    }
+}
+/**
+ * Handle a single annotation line.
+ * @story Updates the current story path when encountering an @story annotation
+ * @req Validates the requirement reference against the current story content
+ * @param line the trimmed annotation line
+ * @param comment JSDoc comment node
+ * @param context ESLint rule context
+ * @param cwd current working directory
+ * @param reqCache cache mapping story paths to sets of requirement IDs
+ * @param storyPath current story path or null
+ * @returns updated story path or null
  */
-function createProgramListener(context) {
+function handleAnnotationLine(line, comment, context, cwd, reqCache, storyPath) {
+    if (line.startsWith("@story")) {
+        const newPath = extractStoryPath(comment);
+        return newPath || storyPath;
+    }
+    else if (line.startsWith("@req")) {
+        validateReqLine(comment, context, line, storyPath, cwd, reqCache);
+        return storyPath;
+    }
+    return storyPath;
+}
+/**
+ * Handle JSDoc story and req annotations.
+ * @param comment any JSDoc comment node
+ * @param context ESLint rule context
+ * @param cwd current working directory
+ * @param reqCache cache mapping story paths to sets of requirement IDs
+ * @param rawStoryPath the last extracted story path or null
+ * @returns updated story path or null
+ */
+function handleComment(comment, context, cwd, reqCache, rawStoryPath) {
+    let storyPath = rawStoryPath;
+    const rawLines = comment.value.split(/\r?\n/);
+    for (const rawLine of rawLines) {
+        const line = rawLine.trim().replace(/^\*+\s*/, "");
+        storyPath = handleAnnotationLine(line, comment, context, cwd, reqCache, storyPath);
+    }
+    return storyPath;
+}
+function programListener(context) {
     const sourceCode = context.getSourceCode();
     const cwd = process.cwd();
     const reqCache = new Map();
@@ -30,62 +138,7 @@ function createProgramListener(context) {
     return function Program() {
         const comments = sourceCode.getAllComments() || [];
         comments.forEach((comment) => {
-            const rawLines = comment.value.split(/\r?\n/);
-            const lines = rawLines.map((rawLine) => rawLine.trim().replace(/^\*+\s*/, ""));
-            lines.forEach((line) => {
-                if (line.startsWith("@story")) {
-                    const parts = line.split(/\s+/);
-                    rawStoryPath = parts[1] || null;
-                }
-                if (line.startsWith("@req")) {
-                    const parts = line.split(/\s+/);
-                    const reqId = parts[1];
-                    if (!reqId || !rawStoryPath) {
-                        return;
-                    }
-                    if (rawStoryPath.includes("..") || path_1.default.isAbsolute(rawStoryPath)) {
-                        context.report({
-                            node: comment,
-                            messageId: "invalidPath",
-                            data: { storyPath: rawStoryPath },
-                        });
-                        return;
-                    }
-                    const resolvedStoryPath = path_1.default.resolve(cwd, rawStoryPath);
-                    if (!resolvedStoryPath.startsWith(cwd + path_1.default.sep) &&
-                        resolvedStoryPath !== cwd) {
-                        context.report({
-                            node: comment,
-                            messageId: "invalidPath",
-                            data: { storyPath: rawStoryPath },
-                        });
-                        return;
-                    }
-                    if (!reqCache.has(resolvedStoryPath)) {
-                        try {
-                            const content = fs_1.default.readFileSync(resolvedStoryPath, "utf8");
-                            const found = new Set();
-                            const regex = /REQ-[A-Z0-9-]+/g;
-                            let match;
-                            while ((match = regex.exec(content)) !== null) {
-                                found.add(match[0]);
-                            }
-                            reqCache.set(resolvedStoryPath, found);
-                        }
-                        catch {
-                            reqCache.set(resolvedStoryPath, new Set());
-                        }
-                    }
-                    const reqSet = reqCache.get(resolvedStoryPath);
-                    if (!reqSet.has(reqId)) {
-                        context.report({
-                            node: comment,
-                            messageId: "reqMissing",
-                            data: { reqId, storyPath: rawStoryPath },
-                        });
-                    }
-                }
-            });
+            rawStoryPath = handleComment(comment, context, cwd, reqCache, rawStoryPath);
         });
     };
 }
@@ -103,7 +156,6 @@ exports.default = {
         schema: [],
     },
     create(context) {
-        const program = createProgramListener(context);
-        return { Program: program };
+        return { Program: programListener(context) };
     },
 };

package/lib/tests/config/eslint-config-validation.test.d.ts

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

package/lib/tests/config/eslint-config-validation.test.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const valid_story_reference_1 = __importDefault(require("../../src/rules/valid-story-reference"));
+/** @story docs/stories/002.0-DEV-ESLINT-CONFIG.story.md */
+describe("ESLint Configuration Setup (Story 002.0-DEV-ESLINT-CONFIG)", () => {
+    it("[REQ-RULE-OPTIONS] rule meta.schema defines expected properties", () => {
+        const schema = valid_story_reference_1.default.meta.schema[0];
+        expect(schema.properties).toHaveProperty("storyDirectories");
+        expect(schema.properties).toHaveProperty("allowAbsolutePaths");
+        expect(schema.properties).toHaveProperty("requireStoryExtension");
+    });
+    it("[REQ-CONFIG-VALIDATION] schema disallows unknown options", () => {
+        const schema = valid_story_reference_1.default.meta.schema[0];
+        expect(schema.additionalProperties).toBe(false);
+    });
+});

package/lib/tests/config/require-story-annotation-config.test.d.ts

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

package/lib/tests/config/require-story-annotation-config.test.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_story_annotation_1 = __importDefault(require("../../src/rules/require-story-annotation"));
+/** @story docs/stories/002.0-DEV-ESLINT-CONFIG.story.md */
+describe("ESLint Configuration Rule Options (Story 002.0-DEV-ESLINT-CONFIG)", () => {
+    it("[REQ-RULE-OPTIONS] require-story-annotation schema defines expected properties", () => {
+        const schema = require_story_annotation_1.default.meta.schema[0];
+        expect(schema.properties).toHaveProperty("scope");
+        expect(schema.properties).toHaveProperty("exportPriority");
+        expect(schema.additionalProperties).toBe(false);
+    });
+});

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

@@ -10,7 +10,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const eslint_1 = require("eslint");
 const require_story_annotation_1 = __importDefault(require("../../src/rules/require-story-annotation"));
-const ruleTester = new eslint_1.RuleTester();
+const ruleTester = new eslint_1.RuleTester({
+    languageOptions: {
+        parserOptions: { ecmaVersion: 2020, sourceType: "module" },
+    },
+});
 describe("Require Story Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", () => {
     ruleTester.run("require-story-annotation", require_story_annotation_1.default, {
         valid: [
@@ -23,6 +27,19 @@ describe("Require Story Annotation Rule (Story 003.0-DEV-FUNCTION-ANNOTATIONS)",
                 code: `// @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
 function foo() {}`,
             },
+            {
+                name: "[REQ-ANNOTATION-REQUIRED] valid on function expression with annotation",
+                code: `/** @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md */\nconst fnExpr = function() {};`,
+            },
+            {
+                name: "[REQ-ANNOTATION-REQUIRED] valid on arrow function with annotation",
+                code: `// @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+const arrowFn = () => {};`,
+            },
+            {
+                name: "[REQ-ANNOTATION-REQUIRED] valid on class method with annotation",
+                code: `class A {\n  /** @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md */\n  method() {}\n}`,
+            },
         ],
         invalid: [
             {
@@ -31,6 +48,72 @@ function foo() {}`,
                 output: `/** @story <story-file>.story.md */\nfunction bar() {}`,
                 errors: [{ messageId: "missingStory" }],
             },
+            {
+                name: "[REQ-ANNOTATION-REQUIRED] missing @story on function expression",
+                code: `const fnExpr = function() {};`,
+                output: `/** @story <story-file>.story.md */\nconst fnExpr = function() {};`,
+                errors: [{ messageId: "missingStory" }],
+            },
+            {
+                name: "[REQ-ANNOTATION-REQUIRED] missing @story on arrow function",
+                code: `const arrowFn = () => {};`,
+                output: `/** @story <story-file>.story.md */\nconst arrowFn = () => {};`,
+                errors: [{ messageId: "missingStory" }],
+            },
+            {
+                name: "[REQ-ANNOTATION-REQUIRED] missing @story on class method",
+                code: `class C {\n  method() {}\n}`,
+                output: `class C {\n  /** @story <story-file>.story.md */\n  method() {}\n}`,
+                errors: [{ messageId: "missingStory" }],
+            },
+        ],
+    });
+    ruleTester.run("require-story-annotation with exportPriority option", require_story_annotation_1.default, {
+        valid: [
+            {
+                name: "[exportPriority] unexported function without @story should be valid",
+                code: `function local() {}`,
+                options: [{ exportPriority: "exported" }],
+            },
+            {
+                name: "[exportPriority] exported with annotation",
+                code: `// @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md\nexport function exportedAnnotated() {}`,
+                options: [{ exportPriority: "exported" }],
+            },
+        ],
+        invalid: [
+            {
+                name: "[exportPriority] exported function missing @story annotation",
+                code: `export function exportedMissing() {}`,
+                output: `/** @story <story-file>.story.md */\nexport function exportedMissing() {}`,
+                options: [{ exportPriority: "exported" }],
+                errors: [{ messageId: "missingStory" }],
+            },
+            {
+                name: "[exportPriority] exported arrow function missing @story annotation",
+                code: `export const arrowExported = () => {};`,
+                output: `/** @story <story-file>.story.md */\nexport const arrowExported = () => {};`,
+                options: [{ exportPriority: "exported" }],
+                errors: [{ messageId: "missingStory" }],
+            },
+        ],
+    });
+    ruleTester.run("require-story-annotation with scope option", require_story_annotation_1.default, {
+        valid: [
+            {
+                name: "[scope] arrow function ignored when scope is FunctionDeclaration",
+                code: `const arrow = () => {};`,
+                options: [{ scope: ["FunctionDeclaration"] }],
+            },
+        ],
+        invalid: [
+            {
+                name: "[scope] function declaration missing annotation when scope is FunctionDeclaration",
+                code: `function onlyDecl() {}`,
+                options: [{ scope: ["FunctionDeclaration"] }],
+                output: `/** @story <story-file>.story.md */\nfunction onlyDecl() {}`,
+                errors: [{ messageId: "missingStory" }],
+            },
         ],
     });
 });

package/lib/tests/rules/valid-req-reference.test.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
+/****
  * Tests for: docs/stories/010.0-DEV-DEEP-VALIDATION.story.md
  * @story docs/stories/010.0-DEV-DEEP-VALIDATION.story.md
  * @req REQ-DEEP-PARSE - Verify valid-req-reference rule enforces existing requirement content

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-traceability",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "description": "A customizable ESLint plugin that enforces traceability annotations in your code, ensuring each implementation is linked to its requirement or test case.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -17,10 +17,11 @@
     "build": "tsc -p tsconfig.json",
     "type-check": "tsc --noEmit -p tsconfig.json",
     "lint": "eslint \"src/**/*.{js,ts}\" \"tests/**/*.{js,ts}\" --max-warnings=0",
-    "test": "jest --ci --bail --coverage",
+    "test": "jest --ci --bail",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "duplication": "jscpd src tests --reporters console --threshold 3",
+    "audit:dev-high": "node scripts/generate-dev-deps-audit.js",
     "smoke-test": "./scripts/smoke-test.sh",
     "prepare": "husky install"
   },
@@ -40,7 +41,7 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/voder-ai/eslint-plugin-traceability/issues"
   },
@@ -49,7 +50,8 @@
     "@eslint/js": "^9.39.1",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/github": "^10.3.5",
+    "@semantic-release/npm": "^10.0.6",
     "@types/eslint": "^9.6.1",
     "@types/jest": "^30.0.0",
     "@types/node": "^24.10.1",
@@ -58,11 +60,11 @@
     "actionlint": "^2.0.6",
     "eslint": "^9.39.1",
     "husky": "^9.1.7",
-    "jest": "^30.2.0",
+    "jest": "^29.7.0",
     "jscpd": "^4.0.5",
     "lint-staged": "^16.2.6",
     "prettier": "^3.6.2",
-    "semantic-release": "^25.0.2",
+    "semantic-release": "^21.1.2",
     "ts-jest": "^29.4.5",
     "typescript": "^5.9.3"
   },
@@ -73,7 +75,6 @@
     "node": ">=14"
   },
   "overrides": {
-    "js-yaml": ">=4.1.1",
-    "tar": ">=6.1.11"
+    "glob": ">=11.0.4"
   }
 }