eslint-plugin-traceability 1.16.1 → 1.17.1

package/lib/tests/perf/maintenance-cli-large-workspace.test.js

@@ -42,6 +42,8 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const perf_hooks_1 = require("perf_hooks");
 const cli_1 = require("../../src/maintenance/cli");
+// Performance budget documented in docs/maintenance-performance-tests.md
+const CLI_LARGE_WORKSPACE_PERF_BUDGET_MS = 5000;
 function createCliLargeWorkspace() {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "traceability-cli-large-"));
     // Create a modestly sized workspace reusing the same shape as the core perf tests,
@@ -71,78 +73,157 @@ export function cli_example_${moduleIndex}_${fileIndex}() {}
         },
     };
 }
+function createDeepNestedCliWorkspace() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "traceability-cli-deep-nested-"));
+    // Create a deeply nested directory structure with a small number of files.
+    for (let branchIndex = 0; branchIndex < 3; branchIndex += 1) {
+        const level1 = path.join(root, `branch-${branchIndex.toString().padStart(3, "0")}`);
+        fs.mkdirSync(level1);
+        const level2 = path.join(level1, "deep", "nested", "structure");
+        fs.mkdirSync(path.join(level1, "deep"), { recursive: true });
+        fs.mkdirSync(path.join(level1, "deep", "nested"), { recursive: true });
+        fs.mkdirSync(level2, { recursive: true });
+        for (let fileIndex = 0; fileIndex < 3; fileIndex += 1) {
+            const filePath = path.join(level2, `deep-file-${fileIndex.toString().padStart(3, "0")}.ts`);
+            const validStory = "cli-valid.story.md";
+            const staleStory = "cli-deep-stale.story.md";
+            const content = `/**
+ * @story ${validStory}
+ * @story ${staleStory}
+ */
+export function cli_deep_example_${branchIndex}_${fileIndex}() {}
+`;
+            fs.writeFileSync(filePath, content, "utf8");
+        }
+    }
+    // Create the valid story file so that only the stale entries are reported.
+    fs.writeFileSync(path.join(root, "cli-valid.story.md"), "# cli valid", "utf8");
+    return {
+        root,
+        cleanup: () => {
+            fs.rmSync(root, { recursive: true, force: true });
+        },
+    };
+}
 describe("Maintenance CLI on large workspaces (Story 009.0-DEV-MAINTENANCE-TOOLS)", () => {
-    let workspace;
-    let originalCwd;
-    beforeAll(() => {
-        originalCwd = process.cwd();
-        workspace = createCliLargeWorkspace();
-        process.chdir(workspace.root);
-    });
-    afterAll(() => {
-        process.chdir(originalCwd);
-        workspace.cleanup();
-    });
     it("[REQ-MAINT-DETECT] detect --json completes within a generous time budget and returns JSON payload", () => {
+        const { root, cleanup } = createCliLargeWorkspace();
+        const originalCwd = process.cwd();
+        process.chdir(root);
         const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
-        const start = perf_hooks_1.performance.now();
-        const exitCode = (0, cli_1.runMaintenanceCli)([
-            "node",
-            "traceability-maint",
-            "detect",
-            "--root",
-            workspace.root,
-            "--json",
-        ]);
-        const durationMs = perf_hooks_1.performance.now() - start;
-        expect(exitCode === 0 || exitCode === 1).toBe(true);
-        expect(durationMs).toBeLessThan(5000);
-        expect(logSpy).toHaveBeenCalledTimes(1);
-        const payloadRaw = String(logSpy.mock.calls[0][0]);
-        const payload = JSON.parse(payloadRaw);
-        expect(payload.root).toBe(workspace.root);
-        expect(Array.isArray(payload.stale)).toBe(true);
-        expect(payload.stale.length).toBeGreaterThan(0);
-        logSpy.mockRestore();
+        try {
+            const start = perf_hooks_1.performance.now();
+            const exitCode = (0, cli_1.runMaintenanceCli)([
+                "node",
+                "traceability-maint",
+                "detect",
+                "--root",
+                root,
+                "--json",
+            ]);
+            const durationMs = perf_hooks_1.performance.now() - start;
+            expect(exitCode === 0 || exitCode === 1).toBe(true);
+            expect(durationMs).toBeLessThan(CLI_LARGE_WORKSPACE_PERF_BUDGET_MS);
+            expect(logSpy).toHaveBeenCalledTimes(1);
+            const payloadRaw = String(logSpy.mock.calls[0][0]);
+            const payload = JSON.parse(payloadRaw);
+            expect(payload.root).toBe(root);
+            expect(Array.isArray(payload.stale)).toBe(true);
+            expect(payload.stale.length).toBeGreaterThan(0);
+        }
+        finally {
+            logSpy.mockRestore();
+            process.chdir(originalCwd);
+            cleanup();
+        }
     });
     it("[REQ-MAINT-REPORT] report --format=json completes within a generous time budget", () => {
+        const { root, cleanup } = createCliLargeWorkspace();
+        const originalCwd = process.cwd();
+        process.chdir(root);
         const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
-        const start = perf_hooks_1.performance.now();
-        const exitCode = (0, cli_1.runMaintenanceCli)([
-            "node",
-            "traceability-maint",
-            "report",
-            "--root",
-            workspace.root,
-            "--format",
-            "json",
-        ]);
-        const durationMs = perf_hooks_1.performance.now() - start;
-        expect(exitCode).toBe(0);
-        expect(durationMs).toBeLessThan(5000);
-        expect(logSpy).toHaveBeenCalledTimes(1);
-        const payloadRaw = String(logSpy.mock.calls[0][0]);
-        const payload = JSON.parse(payloadRaw);
-        expect(payload.root).toBe(workspace.root);
-        expect(typeof payload.report).toBe("string");
-        logSpy.mockRestore();
+        try {
+            const start = perf_hooks_1.performance.now();
+            const exitCode = (0, cli_1.runMaintenanceCli)([
+                "node",
+                "traceability-maint",
+                "report",
+                "--root",
+                root,
+                "--format",
+                "json",
+            ]);
+            const durationMs = perf_hooks_1.performance.now() - start;
+            expect(exitCode).toBe(0);
+            expect(durationMs).toBeLessThan(CLI_LARGE_WORKSPACE_PERF_BUDGET_MS);
+            expect(logSpy).toHaveBeenCalledTimes(1);
+            const payloadRaw = String(logSpy.mock.calls[0][0]);
+            const payload = JSON.parse(payloadRaw);
+            expect(payload.root).toBe(root);
+            expect(typeof payload.report).toBe("string");
+        }
+        finally {
+            logSpy.mockRestore();
+            process.chdir(originalCwd);
+            cleanup();
+        }
     });
     it("[REQ-MAINT-VERIFY] verify completes within a generous time budget and reports stale annotations", () => {
+        const { root, cleanup } = createCliLargeWorkspace();
+        const originalCwd = process.cwd();
+        process.chdir(root);
         const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
-        const start = perf_hooks_1.performance.now();
-        const exitCode = (0, cli_1.runMaintenanceCli)([
-            "node",
-            "traceability-maint",
-            "verify",
-            "--root",
-            workspace.root,
-        ]);
-        const durationMs = perf_hooks_1.performance.now() - start;
-        expect(exitCode).toBe(1);
-        expect(durationMs).toBeLessThan(5000);
-        expect(logSpy).toHaveBeenCalledTimes(1);
-        const message = String(logSpy.mock.calls[0][0]);
-        expect(message).toContain("Stale or invalid traceability annotations detected under");
-        logSpy.mockRestore();
+        try {
+            const start = perf_hooks_1.performance.now();
+            const exitCode = (0, cli_1.runMaintenanceCli)([
+                "node",
+                "traceability-maint",
+                "verify",
+                "--root",
+                root,
+            ]);
+            const durationMs = perf_hooks_1.performance.now() - start;
+            expect(exitCode).toBe(1);
+            expect(durationMs).toBeLessThan(CLI_LARGE_WORKSPACE_PERF_BUDGET_MS);
+            expect(logSpy).toHaveBeenCalledTimes(1);
+            const message = String(logSpy.mock.calls[0][0]);
+            expect(message).toContain("Stale or invalid traceability annotations detected under");
+        }
+        finally {
+            logSpy.mockRestore();
+            process.chdir(originalCwd);
+            cleanup();
+        }
+    });
+    it("[REQ-MAINT-DETECT] detect traverses deeply nested directories within a generous time budget", () => {
+        const { root, cleanup } = createDeepNestedCliWorkspace();
+        const originalCwd = process.cwd();
+        process.chdir(root);
+        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        try {
+            const start = perf_hooks_1.performance.now();
+            const exitCode = (0, cli_1.runMaintenanceCli)([
+                "node",
+                "traceability-maint",
+                "detect",
+                "--root",
+                root,
+                "--json",
+            ]);
+            const durationMs = perf_hooks_1.performance.now() - start;
+            expect(exitCode === 0 || exitCode === 1).toBe(true);
+            expect(durationMs).toBeLessThan(CLI_LARGE_WORKSPACE_PERF_BUDGET_MS);
+            expect(logSpy).toHaveBeenCalledTimes(1);
+            const payloadRaw = String(logSpy.mock.calls[0][0]);
+            const payload = JSON.parse(payloadRaw);
+            expect(payload.root).toBe(root);
+            expect(Array.isArray(payload.stale)).toBe(true);
+            expect(payload.stale.length).toBeGreaterThan(0);
+        }
+        finally {
+            logSpy.mockRestore();
+            process.chdir(originalCwd);
+            cleanup();
+        }
     });
 });

package/lib/tests/perf/maintenance-large-workspace.test.js

@@ -45,6 +45,8 @@ const detect_1 = require("../../src/maintenance/detect");
 const batch_1 = require("../../src/maintenance/batch");
 const report_1 = require("../../src/maintenance/report");
 const update_1 = require("../../src/maintenance/update");
+// Performance budget for large-workspace maintenance tests; documented in docs/maintenance-performance-tests.md.
+const LARGE_WORKSPACE_PERF_BUDGET_MS = 5000;
 /**
  * Shape of the synthetic large workspace:
  * - 10 modules (module-000 .. module-009)
@@ -92,58 +94,75 @@ export function example_${moduleIndex}_${fileIndex}() {}
     };
 }
 describe("Maintenance tools on large workspaces (Story 009.0-DEV-MAINTENANCE-TOOLS)", () => {
-    let workspace;
-    beforeAll(() => {
-        workspace = createLargeWorkspace();
-    });
-    afterAll(() => {
-        workspace.cleanup();
-    });
     it("[REQ-MAINT-DETECT] detectStaleAnnotations completes within a generous time budget", () => {
-        const start = perf_hooks_1.performance.now();
-        const stale = (0, detect_1.detectStaleAnnotations)(workspace.root);
-        const durationMs = perf_hooks_1.performance.now() - start;
-        // Sanity check: we expect at least some stale entries due to the generated stale-story-* references.
-        expect(stale.length).toBeGreaterThan(0);
-        // Guardrail: this operation should remain comfortably under ~5 seconds on CI hardware.
-        expect(durationMs).toBeLessThan(5000);
+        const workspace = createLargeWorkspace();
+        try {
+            const start = perf_hooks_1.performance.now();
+            const stale = (0, detect_1.detectStaleAnnotations)(workspace.root);
+            const durationMs = perf_hooks_1.performance.now() - start;
+            // Sanity check: we expect at least some stale entries due to the generated stale-story-* references.
+            expect(stale.length).toBeGreaterThan(0);
+            // Guardrail: this operation should remain comfortably under ~5 seconds on CI hardware.
+            expect(durationMs).toBeLessThan(LARGE_WORKSPACE_PERF_BUDGET_MS);
+        }
+        finally {
+            workspace.cleanup();
+        }
     });
     it("[REQ-MAINT-VERIFY] verifyAnnotations remains fast on large workspaces", () => {
-        const start = perf_hooks_1.performance.now();
-        const result = (0, batch_1.verifyAnnotations)(workspace.root);
-        const durationMs = perf_hooks_1.performance.now() - start;
-        // With both valid and stale references, verification should report false.
-        expect(result).toBe(false);
-        expect(durationMs).toBeLessThan(5000);
+        const workspace = createLargeWorkspace();
+        try {
+            const start = perf_hooks_1.performance.now();
+            const result = (0, batch_1.verifyAnnotations)(workspace.root);
+            const durationMs = perf_hooks_1.performance.now() - start;
+            // With both valid and stale references, verification should report false.
+            expect(result).toBe(false);
+            expect(durationMs).toBeLessThan(LARGE_WORKSPACE_PERF_BUDGET_MS);
+        }
+        finally {
+            workspace.cleanup();
+        }
     });
     it("[REQ-MAINT-REPORT] generateMaintenanceReport produces output within a generous time budget", () => {
-        const start = perf_hooks_1.performance.now();
-        const report = (0, report_1.generateMaintenanceReport)(workspace.root);
-        const durationMs = perf_hooks_1.performance.now() - start;
-        expect(report).not.toBe("");
-        expect(durationMs).toBeLessThan(5000);
+        const workspace = createLargeWorkspace();
+        try {
+            const start = perf_hooks_1.performance.now();
+            const report = (0, report_1.generateMaintenanceReport)(workspace.root);
+            const durationMs = perf_hooks_1.performance.now() - start;
+            expect(report).not.toBe("");
+            expect(durationMs).toBeLessThan(LARGE_WORKSPACE_PERF_BUDGET_MS);
+        }
+        finally {
+            workspace.cleanup();
+        }
     });
     it("[REQ-MAINT-UPDATE] updateAnnotationReferences and batchUpdateAnnotations remain tractable", () => {
-        const exampleOldPath = "stale-story-0000.story.md";
-        const exampleNewPath = "updated-story-0000.story.md";
-        const singleStart = perf_hooks_1.performance.now();
-        const updatedCount = (0, update_1.updateAnnotationReferences)(workspace.root, exampleOldPath, exampleNewPath);
-        const singleDuration = perf_hooks_1.performance.now() - singleStart;
-        expect(updatedCount).toBeGreaterThan(0);
-        expect(singleDuration).toBeLessThan(5000);
-        const batchStart = perf_hooks_1.performance.now();
-        const totalUpdated = (0, batch_1.batchUpdateAnnotations)(workspace.root, [
-            {
-                oldPath: "stale-story-0001.story.md",
-                newPath: "updated-story-0001.story.md",
-            },
-            {
-                oldPath: "stale-story-0002.story.md",
-                newPath: "updated-story-0002.story.md",
-            },
-        ]);
-        const batchDuration = perf_hooks_1.performance.now() - batchStart;
-        expect(totalUpdated).toBeGreaterThanOrEqual(2);
-        expect(batchDuration).toBeLessThan(5000);
+        const workspace = createLargeWorkspace();
+        try {
+            const exampleOldPath = "stale-story-0000.story.md";
+            const exampleNewPath = "updated-story-0000.story.md";
+            const singleStart = perf_hooks_1.performance.now();
+            const updatedCount = (0, update_1.updateAnnotationReferences)(workspace.root, exampleOldPath, exampleNewPath);
+            const singleDuration = perf_hooks_1.performance.now() - singleStart;
+            expect(updatedCount).toBeGreaterThan(0);
+            expect(singleDuration).toBeLessThan(LARGE_WORKSPACE_PERF_BUDGET_MS);
+            const batchStart = perf_hooks_1.performance.now();
+            const totalUpdated = (0, batch_1.batchUpdateAnnotations)(workspace.root, [
+                {
+                    oldPath: "stale-story-0001.story.md",
+                    newPath: "updated-story-0001.story.md",
+                },
+                {
+                    oldPath: "stale-story-0002.story.md",
+                    newPath: "updated-story-0002.story.md",
+                },
+            ]);
+            const batchDuration = perf_hooks_1.performance.now() - batchStart;
+            expect(totalUpdated).toBeGreaterThanOrEqual(2);
+            expect(batchDuration).toBeLessThan(LARGE_WORKSPACE_PERF_BUDGET_MS);
+        }
+        finally {
+            workspace.cleanup();
+        }
     });
 });

package/lib/tests/rules/no-redundant-annotation.test.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @req REQ-STATEMENT-SIGNIFICANCE - Verify that simple statements are treated as redundant when covered by scope
  * @req REQ-SAFE-REMOVAL - Verify that auto-fix removes only redundant annotations and preserves code
  * @req REQ-DIFFERENT-REQUIREMENTS - Verify that annotations with different requirement IDs are preserved
+ * @req REQ-CATCH-BLOCK-HANDLING - Verify that catch block annotations are not incorrectly treated as redundant
  */
 const eslint_1 = require("eslint");
 const no_redundant_annotation_1 = __importDefault(require("../../src/rules/no-redundant-annotation"));
@@ -37,6 +38,10 @@ describe("no-redundant-annotation rule (Story 027.0-DEV-REDUNDANT-ANNOTATION-DET
                 name: "[REQ-SCOPE-ANALYSIS] preserves annotations on both branch and statement when they intentionally duplicate each other",
                 code: `function example() {\n  if (condition) { // @story docs/stories/007.0-EXAMPLE.story.md @req REQ-BRANCH\n    // @story docs/stories/007.0-EXAMPLE.story.md\n    // @req REQ-BRANCH\n    doBranchWork();\n  }\n}`,
             },
+            {
+                name: "[REQ-CATCH-BLOCK-HANDLING] preserves catch block annotation from issue #6 scenario",
+                code: `async function example() {\n  try {\n    // @story prompts/004.0-DEV-FILTER-VULNERABLE-VERSIONS.story.md\n    // @supports prompts/004.0-DEV-FILTER-VULNERABLE-VERSIONS.md REQ-SAFE-ONLY\n    if (isSafeVersion({ version, vulnerabilityData })) {\n      return version;\n    }\n\n    // @story prompts/004.0-DEV-FILTER-VULNERABLE-VERSIONS.story.md\n    // @supports prompts/004.0-DEV-FILTER-VULNERABLE-VERSIONS.md REQ-SAFE-ONLY\n    if (!vulnerabilityData.isVulnerable) {\n      return version;\n    }\n  } catch (error) {\n    // @story prompts/004.0-DEV-FILTER-VULNERABLE-VERSIONS.story.md\n    // @supports prompts/004.0-DEV-FILTER-VULNERABLE-VERSIONS.md REQ-SAFE-ONLY\n    return null;\n  }\n}`,
+            },
         ],
         invalid: [
             {

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

@@ -100,6 +100,11 @@ describe('Vitest suite', () => {
   bench('Vitest bench', () => {});
 });`,
             },
+            {
+                name: "[REQ-TEST-CALLBACK-EXCLUSION][Story 003.0] additionalTestHelperNames excludes configured helper callbacks when excludeTestCallbacks=true",
+                code: `withTestCase("does something", () => {});`,
+                options: [{ additionalTestHelperNames: ["withTestCase"] }],
+            },
         ],
         invalid: [
             {
@@ -216,6 +221,22 @@ describe('Vitest suite', () => {
                     },
                 ],
             },
+            {
+                name: "[REQ-TEST-CALLBACK-EXCLUSION][Story 003.0] bench callback still reported even when included in additionalTestHelperNames",
+                code: `bench("bench case", () => {});`,
+                options: [{ additionalTestHelperNames: ["bench"], autoFix: false }],
+                errors: [
+                    {
+                        messageId: "missingStory",
+                        suggestions: [
+                            {
+                                desc: `Add traceability annotation for function '(anonymous)' using @supports (preferred) or @story (legacy), for example: /** @supports docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md */`,
+                                output: `bench("bench case", /** @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md */\n() => {});`,
+                            },
+                        ],
+                    },
+                ],
+            },
         ],
     });
     ruleTester.run("require-story-annotation with exportPriority option", require_story_annotation_1.default, {

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

@@ -401,4 +401,73 @@ describe("Require Story Helpers (Story 003.0)", () => {
         });
         expect(result).toBeTruthy();
     });
+    /**
+     * Additional coverage for nested and helper-wrapped test callbacks.
+     * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+     * @req REQ-TEST-CALLBACK-EXCLUSION - Document how nested and wrapper-based callbacks interact with exclusion logic
+     */
+    test("[REQ-TEST-CALLBACK-EXCLUSION] Nested anonymous arrow inside it() callback is excluded via nested-function inheritance", () => {
+        const outerCallback = {
+            type: "ArrowFunctionExpression",
+            parent: {
+                type: "CallExpression",
+                callee: { type: "Identifier", name: "it" },
+            },
+        };
+        const innerCallback = {
+            type: "ArrowFunctionExpression",
+            parent: {
+                type: "BlockStatement",
+                parent: outerCallback,
+            },
+        };
+        // Outer callback is treated as a test framework callback and excluded.
+        const outerResult = (0, require_story_helpers_1.shouldProcessNode)(outerCallback, require_story_helpers_1.DEFAULT_SCOPE);
+        // Inner anonymous arrow inherits from its nested parent and is also excluded.
+        const innerResult = (0, require_story_helpers_1.shouldProcessNode)(innerCallback, require_story_helpers_1.DEFAULT_SCOPE);
+        expect(outerResult).toBeFalsy();
+        expect(innerResult).toBeFalsy();
+    });
+    test("[REQ-TEST-CALLBACK-EXCLUSION] Arrow callback passed to local wrapper around describe() is not treated as a test callback", () => {
+        const node = {
+            type: "ArrowFunctionExpression",
+            parent: {
+                type: "CallExpression",
+                callee: { type: "Identifier", name: "withDescribe" },
+            },
+        };
+        const result = (0, require_story_helpers_1.shouldProcessNode)(node, require_story_helpers_1.DEFAULT_SCOPE);
+        expect(result).toBeTruthy();
+    });
+    /**
+     * Additional coverage for configurable test helper names.
+     * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+     * @req REQ-TEST-CALLBACK-EXCLUSION - Verify additionalTestHelperNames interacts correctly with exclusion logic
+     */
+    test("[REQ-TEST-CALLBACK-EXCLUSION] Arrow callback passed to configured additionalTestHelperNames helper is excluded by default", () => {
+        const node = {
+            type: "ArrowFunctionExpression",
+            parent: {
+                type: "CallExpression",
+                callee: { type: "Identifier", name: "withTest" },
+            },
+        };
+        const result = (0, require_story_helpers_1.shouldProcessNode)(node, require_story_helpers_1.DEFAULT_SCOPE, "all", {
+            additionalTestHelperNames: ["withTest"],
+        });
+        expect(result).toBeFalsy();
+    });
+    test("[REQ-TEST-CALLBACK-EXCLUSION] bench callback is never excluded even when included in additionalTestHelperNames", () => {
+        const node = {
+            type: "ArrowFunctionExpression",
+            parent: {
+                type: "CallExpression",
+                callee: { type: "Identifier", name: "bench" },
+            },
+        };
+        const result = (0, require_story_helpers_1.shouldProcessNode)(node, require_story_helpers_1.DEFAULT_SCOPE, "all", {
+            additionalTestHelperNames: ["bench"],
+        });
+        expect(result).toBeTruthy();
+    });
 });

package/lib/tests/utils/{annotation-checker-branches.test.d.ts → annotation-checker-autofix-behavior.test.d.ts}

@@ -1,5 +1,5 @@
 /**
- * Focused branch coverage tests for annotation-checker helper.
+ * Focused autofix behavior tests for annotation-checker helper.
  * @supports docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md REQ-ANNOTATION-AUTOFIX REQ-ANNOTATION-REPORTING
  */
 export {};

package/lib/tests/utils/{annotation-checker-branches.test.js → annotation-checker-autofix-behavior.test.js}

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Focused branch coverage tests for annotation-checker helper.
+ * Focused autofix behavior tests for annotation-checker helper.
  * @supports docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md REQ-ANNOTATION-AUTOFIX REQ-ANNOTATION-REPORTING
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -34,7 +34,7 @@ function createContextStub() {
     };
     return { context, report };
 }
-describe("annotation-checker helper branch coverage (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", () => {
+describe("annotation-checker helper autofix behavior (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", () => {
     it("[REQ-ANNOTATION-AUTOFIX] attaches fix directly to node when parent is missing", () => {
         const { context, report } = createContextStub();
         const node = { type: "FunctionDeclaration" }; // no parent property

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-traceability",
-  "version": "1.16.1",
+  "version": "1.17.1",
   "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",
@@ -88,7 +88,7 @@
     "jest": "^30.2.0",
     "jscpd": "^4.0.5",
     "lint-staged": "^16.2.7",
-    "prettier": "^3.6.2",
+    "prettier": "^3.7.4",
     "semantic-release": "25.0.2",
     "ts-jest": "^29.4.6",
     "typescript": "^5.9.3",