eslint-plugin-traceability 1.1.7 → 1.1.9

package/README.md

@@ -15,7 +15,7 @@ Prerequisites: Node.js v12+ and ESLint v9+.
 2. Using Yarn  
    yarn add --dev eslint-plugin-traceability
 
-For detailed setup with ESLint v9, see docs/eslint-9-setup-guide.md.
+For detailed setup with ESLint v9, see user-docs/eslint-9-setup-guide.md.
 
 ## Usage
 
@@ -145,7 +145,7 @@ The CLI integration tests are also executed automatically in CI under the `integ
 
 ## Documentation Links
 
-- ESLint v9 Setup Guide: docs/eslint-9-setup-guide.md
+- ESLint v9 Setup Guide: user-docs/eslint-9-setup-guide.md
 - Plugin Development Guide: docs/eslint-plugin-development-guide.md
 - API Reference: user-docs/api-reference.md
 - Examples: user-docs/examples.md

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,10 +1,83 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
+/****
  * 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 });
+/**
+ * Gather leading comments for a node, with fallback for SwitchCase.
+ * @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
+ * @req REQ-BRANCH-DETECTION - Gather comments including fallback scanning
+ */
+function gatherCommentText(sourceCode, node) {
+    if (node.type === "SwitchCase") {
+        const lines = sourceCode.lines;
+        const startLine = node.loc.start.line;
+        let i = startLine - 1;
+        const fallbackComments = [];
+        while (i > 0) {
+            const lineText = lines[i - 1];
+            if (/^\s*(\/\/|\/\*)/.test(lineText)) {
+                fallbackComments.unshift(lineText.trim());
+                i--;
+            }
+            else if (/^\s*$/.test(lineText)) {
+                break;
+            }
+            else {
+                break;
+            }
+        }
+        return fallbackComments.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) {
+        const reportObj = {
+            node,
+            messageId: "missingAnnotation",
+            data: { missing: "@story" },
+        };
+        if (node.type !== "CatchClause") {
+            if (node.type === "SwitchCase") {
+                const indent = " ".repeat(node.loc.start.column);
+                reportObj.fix = (fixer) => fixer.insertTextBefore(node, `// @story <story-file>.story.md\n${indent}`);
+            }
+            else {
+                reportObj.fix = (fixer) => fixer.insertTextBefore(node, `// @story <story-file>.story.md\n`);
+            }
+        }
+        context.report(reportObj);
+    }
+    if (missingReq) {
+        const reportObj = {
+            node,
+            messageId: "missingAnnotation",
+            data: { missing: "@req" },
+        };
+        if (!missingStory && node.type !== "CatchClause") {
+            if (node.type === "SwitchCase") {
+                const indent = " ".repeat(node.loc.start.column);
+                reportObj.fix = (fixer) => fixer.insertTextBefore(node, `// @req <REQ-ID>\n${indent}`);
+            }
+            else {
+                reportObj.fix = (fixer) => fixer.insertTextBefore(node, `// @req <REQ-ID>\n`);
+            }
+        }
+        context.report(reportObj);
+    }
+}
 exports.default = {
     meta: {
         type: "problem",
@@ -20,92 +93,21 @@ exports.default = {
     },
     create(context) {
         const sourceCode = context.getSourceCode();
-        /**
-         * Helper to check a branch AST node for traceability annotations.
-         * @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
-         * @req REQ-BRANCH-DETECTION - Detect significant code branches for traceability annotations
-         */
-        function checkBranch(node) {
-            // @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
-            // @req REQ-BRANCH-DETECTION - Skip default switch cases during annotation checks
-            // skip default cases in switch
-            if (node.type === "SwitchCase" && node.test == null) {
-                return;
-            }
-            // collect comments before node
-            let comments = sourceCode.getCommentsBefore(node) || [];
-            // @story docs/stories/004.0-DEV-BRANCH-ANNOTATIONS.story.md
-            // @req REQ-BRANCH-DETECTION - Fallback scanning for SwitchCase when leading comments are absent
-            // fallback scanning for SwitchCase if no leading comment nodes
-            /* istanbul ignore if */
-            if (node.type === "SwitchCase" && comments.length === 0) {
-                const lines = sourceCode.lines;
-                const startLine = node.loc.start.line;
-                let i = startLine - 1;
-                const fallbackComments = [];
-                while (i > 0) {
-                    const lineText = lines[i - 1];
-                    if (/^\s*(\/\/|\/\*)/.test(lineText)) {
-                        fallbackComments.unshift(lineText.trim());
-                        i--;
-                    }
-                    else if (/^\s*$/.test(lineText)) {
-                        break;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                comments = fallbackComments.map((text) => ({ value: text }));
-            }
-            const text = comments.map((c) => c.value).join(" ");
-            const missingStory = !/@story\b/.test(text);
-            const missingReq = !/@req\b/.test(text);
-            if (missingStory) {
-                const reportObj = {
-                    node,
-                    messageId: "missingAnnotation",
-                    data: { missing: "@story" },
-                };
-                if (node.type !== "CatchClause") {
-                    if (node.type === "SwitchCase") {
-                        const indent = " ".repeat(node.loc.start.column);
-                        reportObj.fix = (fixer) => fixer.insertTextBefore(node, `// @story <story-file>.story.md\n${indent}`);
-                    }
-                    else {
-                        reportObj.fix = (fixer) => fixer.insertTextBefore(node, `// @story <story-file>.story.md\n`);
-                    }
-                }
-                context.report(reportObj);
-            }
-            if (missingReq) {
-                const reportObj = {
-                    node,
-                    messageId: "missingAnnotation",
-                    data: { missing: "@req" },
-                };
-                if (!missingStory && node.type !== "CatchClause") {
-                    if (node.type === "SwitchCase") {
-                        const indent = " ".repeat(node.loc.start.column);
-                        reportObj.fix = (fixer) => fixer.insertTextBefore(node, `// @req <REQ-ID>\n${indent}`);
-                    }
-                    else {
-                        reportObj.fix = (fixer) => fixer.insertTextBefore(node, `// @req <REQ-ID>\n`);
-                    }
-                }
-                context.report(reportObj);
-            }
-        }
         return {
-            IfStatement: checkBranch,
-            SwitchCase: checkBranch,
-            TryStatement: checkBranch,
-            CatchClause: checkBranch,
-            ForStatement: checkBranch,
-            ForOfStatement: checkBranch,
-            ForInStatement: checkBranch,
-            WhileStatement: checkBranch,
-            DoWhileStatement: checkBranch,
+            IfStatement: (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),
+            ForOfStatement: (node) => checkBranchNode(sourceCode, context, node),
+            ForInStatement: (node) => checkBranchNode(sourceCode, context, node),
+            WhileStatement: (node) => checkBranchNode(sourceCode, context, node),
+            DoWhileStatement: (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

@@ -14,6 +14,134 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+/**
+ * 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 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();
+    let rawStoryPath = null;
+    return function Program() {
+        const comments = sourceCode.getAllComments() || [];
+        comments.forEach((comment) => {
+            rawStoryPath = handleComment(comment, context, cwd, reqCache, rawStoryPath);
+        });
+    };
+}
 exports.default = {
     meta: {
         type: "problem",
@@ -28,77 +156,6 @@ exports.default = {
         schema: [],
     },
     create(context) {
-        const sourceCode = context.getSourceCode();
-        const cwd = process.cwd();
-        // Cache for resolved story file paths to parsed set of requirement IDs
-        const reqCache = new Map();
-        let rawStoryPath = null;
-        return {
-            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;
-                            }
-                            // Protect against path traversal and absolute paths
-                            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;
-                            }
-                            // Load and parse story file if not cached
-                            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 {
-                                    // Unable to read file, treat as no requirements
-                                    reqCache.set(resolvedStoryPath, new Set());
-                                }
-                            }
-                            const reqSet = reqCache.get(resolvedStoryPath);
-                            if (!reqSet.has(reqId)) {
-                                context.report({
-                                    node: comment,
-                                    messageId: "reqMissing",
-                                    data: { reqId, storyPath: rawStoryPath },
-                                });
-                            }
-                        }
-                    });
-                });
-            },
-        };
+        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/maintenance/detect-isolated.test.js

@@ -48,30 +48,32 @@ describe("detectStaleAnnotations isolated (Story 009.0-DEV-MAINTENANCE-TOOLS)",
         expect(result).toEqual([]);
     });
     it("[REQ-MAINT-DETECT] detects stale annotations in nested directories", () => {
-        // Arrange
         const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tmp-nested-"));
-        const nestedDir = path.join(tmpDir, "nested");
-        fs.mkdirSync(nestedDir);
-        const filePath1 = path.join(tmpDir, "file1.ts");
-        const filePath2 = path.join(nestedDir, "file2.ts");
-        const content1 = `
+        try {
+            const nestedDir = path.join(tmpDir, "nested");
+            fs.mkdirSync(nestedDir);
+            const filePath1 = path.join(tmpDir, "file1.ts");
+            const filePath2 = path.join(nestedDir, "file2.ts");
+            const content1 = `
 /**
  * @story stale1.story.md
  */
 `;
-        fs.writeFileSync(filePath1, content1, "utf8");
-        const content2 = `
+            fs.writeFileSync(filePath1, content1, "utf8");
+            const content2 = `
 /**
  * @story stale2.story.md
  */
 `;
-        fs.writeFileSync(filePath2, content2, "utf8");
-        // Act
-        const result = (0, detect_1.detectStaleAnnotations)(tmpDir);
-        // Assert
-        expect(result).toHaveLength(2);
-        expect(result).toContain("stale1.story.md");
-        expect(result).toContain("stale2.story.md");
+            fs.writeFileSync(filePath2, content2, "utf8");
+            const result = (0, detect_1.detectStaleAnnotations)(tmpDir);
+            expect(result).toHaveLength(2);
+            expect(result).toContain("stale1.story.md");
+            expect(result).toContain("stale2.story.md");
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
     });
     it("[REQ-MAINT-DETECT] throws error on permission denied", () => {
         const tmpDir2 = fs.mkdtempSync(path.join(os.tmpdir(), "tmp-perm-"));

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

@@ -15,9 +15,13 @@ const detect_1 = require("../../src/maintenance/detect");
 describe("detectStaleAnnotations (Story 009.0-DEV-MAINTENANCE-TOOLS)", () => {
     it("[REQ-MAINT-DETECT] should return empty array when no stale annotations", () => {
         const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "detect-test-"));
-        // No annotation files are created in tmpDir to simulate no stale annotations
-        const result = (0, detect_1.detectStaleAnnotations)(tmpDir);
-        expect(result).toEqual([]);
-        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        try {
+            // No annotation files are created in tmpDir to simulate no stale annotations
+            const result = (0, detect_1.detectStaleAnnotations)(tmpDir);
+            expect(result).toEqual([]);
+        }
+        finally {
+            fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        }
     });
 });

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

@@ -44,23 +44,23 @@ const os = __importStar(require("os"));
 const update_1 = require("../../src/maintenance/update");
 describe("updateAnnotationReferences isolated (Story 009.0-DEV-MAINTENANCE-TOOLS)", () => {
     it("[REQ-MAINT-UPDATE] updates @story annotations in files", () => {
-        // Create a temporary directory for testing
         const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tmp-"));
-        const filePath = path.join(tmpDir, "file.ts");
-        const originalContent = `
+        try {
+            const filePath = path.join(tmpDir, "file.ts");
+            const originalContent = `
 /**
  * @story old.path.md
  */
 function foo() {}
 `;
-        fs.writeFileSync(filePath, originalContent, "utf8");
-        // Run the function under test
-        const count = (0, update_1.updateAnnotationReferences)(tmpDir, "old.path.md", "new.path.md");
-        expect(count).toBe(1);
-        // Verify the file content was updated
-        const updatedContent = fs.readFileSync(filePath, "utf8");
-        expect(updatedContent).toContain("@story new.path.md");
-        // Cleanup temporary directory
-        fs.rmSync(tmpDir, { recursive: true, force: true });
+            fs.writeFileSync(filePath, originalContent, "utf8");
+            const count = (0, update_1.updateAnnotationReferences)(tmpDir, "old.path.md", "new.path.md");
+            expect(count).toBe(1);
+            const updatedContent = fs.readFileSync(filePath, "utf8");
+            expect(updatedContent).toContain("@story new.path.md");
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
     });
 });

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.7",
+  "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,6 +75,6 @@
     "node": ">=14"
   },
   "overrides": {
-    "js-yaml": ">=4.1.1"
+    "glob": ">=11.0.4"
   }
 }