gswd 1.0.0 → 1.1.0

package/dist/tests/specify-journeys.test.js

@@ -0,0 +1,440 @@
+"use strict";
+/**
+ * Specify Journeys module tests — Journey types, scope/priority heuristics,
+ * FR extraction, bidirectional cross-linking, traceability, coverage validation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const specify_journeys_js_1 = require("../lib/specify-journeys.js");
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function makeStep(number, action) {
+    return { number, action, frIds: [] };
+}
+function makeValidJourney(overrides = {}) {
+    return {
+        id: 'J-001',
+        name: 'Test Journey',
+        type: 'core_action',
+        preconditions: ['User is logged in'],
+        steps: [
+            makeStep(1, 'User opens dashboard'),
+            makeStep(2, 'User clicks create button'),
+            makeStep(3, 'User fills in form fields'),
+            makeStep(4, 'User submits the form'),
+            makeStep(5, 'System confirms creation'),
+        ],
+        success: 'New item is created and visible',
+        failureModes: [
+            { scenario: 'Network timeout during submission', handling: 'Show retry dialog' },
+            { scenario: 'Validation error on required fields', handling: 'Highlight invalid fields' },
+        ],
+        acceptanceTests: ['User can create a new item without errors'],
+        linkedFRs: [],
+        linkedNFRs: [],
+        ...overrides,
+    };
+}
+// ─── JOURNEY_TYPES constant ──────────────────────────────────────────────────
+(0, node_test_1.describe)('JOURNEY_TYPES', () => {
+    (0, node_test_1.it)('has exactly 6 entries', () => {
+        assert.strictEqual(specify_journeys_js_1.JOURNEY_TYPES.length, 6);
+    });
+    (0, node_test_1.it)('contains all required types', () => {
+        const types = specify_journeys_js_1.JOURNEY_TYPES.map((t) => t.type);
+        assert.ok(types.includes('onboarding'));
+        assert.ok(types.includes('core_action'));
+        assert.ok(types.includes('view_results'));
+        assert.ok(types.includes('settings'));
+        assert.ok(types.includes('error_states'));
+        assert.ok(types.includes('empty_states'));
+    });
+    (0, node_test_1.it)('each has a non-empty displayName', () => {
+        for (const entry of specify_journeys_js_1.JOURNEY_TYPES) {
+            assert.ok(entry.displayName.length > 0, `${entry.type} has empty displayName`);
+        }
+    });
+});
+// ─── assignScope ─────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('assignScope', () => {
+    (0, node_test_1.it)('onboarding -> v1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignScope)('onboarding'), 'v1');
+    });
+    (0, node_test_1.it)('core_action -> v1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignScope)('core_action'), 'v1');
+    });
+    (0, node_test_1.it)('error_states -> v1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignScope)('error_states'), 'v1');
+    });
+    (0, node_test_1.it)('empty_states -> v1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignScope)('empty_states'), 'v1');
+    });
+    (0, node_test_1.it)('view_results -> v1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignScope)('view_results'), 'v1');
+    });
+    (0, node_test_1.it)('settings -> v1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignScope)('settings'), 'v1');
+    });
+});
+// ─── assignPriority ──────────────────────────────────────────────────────────
+(0, node_test_1.describe)('assignPriority', () => {
+    (0, node_test_1.it)('core_action -> P0', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignPriority)('core_action'), 'P0');
+    });
+    (0, node_test_1.it)('onboarding -> P0', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignPriority)('onboarding'), 'P0');
+    });
+    (0, node_test_1.it)('error_states -> P1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignPriority)('error_states'), 'P1');
+    });
+    (0, node_test_1.it)('empty_states -> P1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignPriority)('empty_states'), 'P1');
+    });
+    (0, node_test_1.it)('view_results -> P1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignPriority)('view_results'), 'P1');
+    });
+    (0, node_test_1.it)('settings -> P1', () => {
+        assert.strictEqual((0, specify_journeys_js_1.assignPriority)('settings'), 'P1');
+    });
+});
+// ─── generateJourneyStructure ────────────────────────────────────────────────
+(0, node_test_1.describe)('generateJourneyStructure', () => {
+    (0, node_test_1.it)('produces J-001 format ID for journeyNumber=1', () => {
+        const j = (0, specify_journeys_js_1.generateJourneyStructure)('onboarding', 1);
+        assert.strictEqual(j.id, 'J-001');
+    });
+    (0, node_test_1.it)('produces J-012 format ID for journeyNumber=12', () => {
+        const j = (0, specify_journeys_js_1.generateJourneyStructure)('core_action', 12);
+        assert.strictEqual(j.id, 'J-012');
+    });
+    (0, node_test_1.it)('has correct type field', () => {
+        const j = (0, specify_journeys_js_1.generateJourneyStructure)('settings', 3);
+        assert.strictEqual(j.type, 'settings');
+    });
+    (0, node_test_1.it)('has empty but initialized arrays', () => {
+        const j = (0, specify_journeys_js_1.generateJourneyStructure)('core_action', 1);
+        assert.ok(Array.isArray(j.steps));
+        assert.strictEqual(j.steps.length, 0);
+        assert.ok(Array.isArray(j.failureModes));
+        assert.strictEqual(j.failureModes.length, 0);
+        assert.ok(Array.isArray(j.acceptanceTests));
+        assert.strictEqual(j.acceptanceTests.length, 0);
+        assert.ok(Array.isArray(j.linkedFRs));
+        assert.strictEqual(j.linkedFRs.length, 0);
+        assert.ok(Array.isArray(j.linkedNFRs));
+        assert.strictEqual(j.linkedNFRs.length, 0);
+    });
+    (0, node_test_1.it)('uses display name from JOURNEY_TYPES', () => {
+        const j = (0, specify_journeys_js_1.generateJourneyStructure)('view_results', 3);
+        assert.strictEqual(j.name, 'View Results/History');
+    });
+});
+// ─── validateJourney ─────────────────────────────────────────────────────────
+(0, node_test_1.describe)('validateJourney', () => {
+    (0, node_test_1.it)('valid journey with all required fields passes', () => {
+        const result = (0, specify_journeys_js_1.validateJourney)(makeValidJourney());
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.errors.length, 0);
+    });
+    (0, node_test_1.it)('journey with < 2 failure modes fails', () => {
+        const j = makeValidJourney({
+            failureModes: [{ scenario: 'Only one', handling: 'Handle' }],
+        });
+        const result = (0, specify_journeys_js_1.validateJourney)(j);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('failure modes')));
+    });
+    (0, node_test_1.it)('journey with 0 acceptance tests fails', () => {
+        const j = makeValidJourney({ acceptanceTests: [] });
+        const result = (0, specify_journeys_js_1.validateJourney)(j);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('acceptance tests')));
+    });
+    (0, node_test_1.it)('journey with empty preconditions fails', () => {
+        const j = makeValidJourney({ preconditions: [] });
+        const result = (0, specify_journeys_js_1.validateJourney)(j);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('preconditions')));
+    });
+    (0, node_test_1.it)('journey with empty success fails', () => {
+        const j = makeValidJourney({ success: '' });
+        const result = (0, specify_journeys_js_1.validateJourney)(j);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('success')));
+    });
+    (0, node_test_1.it)('error_states journey with 3 steps passes (lower minimum)', () => {
+        const j = makeValidJourney({
+            type: 'error_states',
+            steps: [
+                makeStep(1, 'Error occurs'),
+                makeStep(2, 'System displays error'),
+                makeStep(3, 'User acknowledges'),
+            ],
+        });
+        const result = (0, specify_journeys_js_1.validateJourney)(j);
+        assert.strictEqual(result.valid, true);
+    });
+    (0, node_test_1.it)('core_action journey with 4 steps fails (needs >= 5)', () => {
+        const j = makeValidJourney({
+            type: 'core_action',
+            steps: [
+                makeStep(1, 'Step 1'),
+                makeStep(2, 'Step 2'),
+                makeStep(3, 'Step 3'),
+                makeStep(4, 'Step 4'),
+            ],
+        });
+        const result = (0, specify_journeys_js_1.validateJourney)(j);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('steps')));
+    });
+    (0, node_test_1.it)('failure mode > 200 chars fails conciseness check', () => {
+        const longScenario = 'A'.repeat(201);
+        const j = makeValidJourney({
+            failureModes: [
+                { scenario: longScenario, handling: 'Handle' },
+                { scenario: 'Short', handling: 'Handle' },
+            ],
+        });
+        const result = (0, specify_journeys_js_1.validateJourney)(j);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('too long')));
+    });
+});
+// ─── extractFRsFromJourneys ─────────────────────────────────────────────────
+(0, node_test_1.describe)('extractFRsFromJourneys', () => {
+    (0, node_test_1.it)('single journey with 5 steps produces 5 FRs', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        assert.strictEqual(frs.length, 5);
+    });
+    (0, node_test_1.it)('FR IDs are sequential: FR-001 through FR-005', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        assert.strictEqual(frs[0].id, 'FR-001');
+        assert.strictEqual(frs[1].id, 'FR-002');
+        assert.strictEqual(frs[2].id, 'FR-003');
+        assert.strictEqual(frs[3].id, 'FR-004');
+        assert.strictEqual(frs[4].id, 'FR-005');
+    });
+    (0, node_test_1.it)('core action journey FRs have scope=v1 and priority=P0', () => {
+        const journeys = [makeValidJourney({ type: 'core_action' })];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        for (const fr of frs) {
+            assert.strictEqual(fr.scope, 'v1');
+            assert.strictEqual(fr.priority, 'P0');
+        }
+    });
+    (0, node_test_1.it)('settings journey FRs have scope=v1 and priority=P1', () => {
+        const journeys = [
+            makeValidJourney({
+                id: 'J-004',
+                type: 'settings',
+            }),
+        ];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        for (const fr of frs) {
+            assert.strictEqual(fr.scope, 'v1');
+            assert.strictEqual(fr.priority, 'P1');
+        }
+    });
+    (0, node_test_1.it)('FR sourceJourneys contains the parent journey ID', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        for (const fr of frs) {
+            assert.ok(fr.sourceJourneys.includes('J-001'));
+        }
+    });
+    (0, node_test_1.it)('FR sourceSteps contains J-XXX step N format', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        assert.ok(frs[0].sourceSteps.includes('J-001 step 1'));
+        assert.ok(frs[2].sourceSteps.includes('J-001 step 3'));
+    });
+    (0, node_test_1.it)('multiple journeys produce sequentially numbered FRs', () => {
+        const j1 = makeValidJourney({
+            id: 'J-001',
+            steps: [makeStep(1, 'Action A'), makeStep(2, 'Action B'), makeStep(3, 'Action C'), makeStep(4, 'Action D'), makeStep(5, 'Action E')],
+        });
+        const j2 = makeValidJourney({
+            id: 'J-002',
+            type: 'settings',
+            steps: [makeStep(1, 'Action F'), makeStep(2, 'Action G'), makeStep(3, 'Action H'), makeStep(4, 'Action I'), makeStep(5, 'Action J')],
+        });
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)([j1, j2]);
+        assert.strictEqual(frs.length, 10);
+        assert.strictEqual(frs[0].id, 'FR-001');
+        assert.strictEqual(frs[9].id, 'FR-010');
+    });
+    (0, node_test_1.it)('duplicate step descriptions merge into single FR with multiple sources', () => {
+        const j1 = makeValidJourney({
+            id: 'J-001',
+            steps: [makeStep(1, 'User logs in'), makeStep(2, 'Step B'), makeStep(3, 'Step C'), makeStep(4, 'Step D'), makeStep(5, 'Step E')],
+        });
+        const j2 = makeValidJourney({
+            id: 'J-002',
+            steps: [makeStep(1, 'User logs in'), makeStep(2, 'Step F'), makeStep(3, 'Step G'), makeStep(4, 'Step H'), makeStep(5, 'Step I')],
+        });
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)([j1, j2]);
+        // "User logs in" should be merged, so 5 + 5 - 1 = 9 FRs
+        assert.strictEqual(frs.length, 9);
+        const loginFr = frs.find((fr) => fr.description === 'User logs in');
+        assert.ok(loginFr);
+        assert.ok(loginFr.sourceJourneys.includes('J-001'));
+        assert.ok(loginFr.sourceJourneys.includes('J-002'));
+        assert.strictEqual(loginFr.sourceSteps.length, 2);
+    });
+});
+// ─── Bidirectional cross-linking ─────────────────────────────────────────────
+(0, node_test_1.describe)('Bidirectional cross-linking', () => {
+    (0, node_test_1.it)('journey.linkedFRs contains all FRs from its steps', () => {
+        const journeys = [makeValidJourney()];
+        (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        assert.strictEqual(journeys[0].linkedFRs.length, 5);
+        assert.ok(journeys[0].linkedFRs.includes('FR-001'));
+        assert.ok(journeys[0].linkedFRs.includes('FR-005'));
+    });
+    (0, node_test_1.it)('each step.frIds contains the FR IDs generated from it', () => {
+        const journeys = [makeValidJourney()];
+        (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        assert.ok(journeys[0].steps[0].frIds.includes('FR-001'));
+        assert.ok(journeys[0].steps[4].frIds.includes('FR-005'));
+    });
+    (0, node_test_1.it)('FR.sourceJourneys correctly references back to the journey', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        for (const fr of frs) {
+            assert.ok(fr.sourceJourneys.includes('J-001'));
+        }
+    });
+});
+// ─── buildTraceabilityMap ────────────────────────────────────────────────────
+(0, node_test_1.describe)('buildTraceabilityMap', () => {
+    (0, node_test_1.it)('produces one entry per FR', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        const map = (0, specify_journeys_js_1.buildTraceabilityMap)(frs);
+        assert.strictEqual(map.length, frs.length);
+    });
+    (0, node_test_1.it)('each entry has correct journeyRefs format', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        const map = (0, specify_journeys_js_1.buildTraceabilityMap)(frs);
+        assert.ok(map[0].journeyRefs[0].includes('J-001 (step 1)'));
+    });
+    (0, node_test_1.it)('entries sorted by FR ID', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        const map = (0, specify_journeys_js_1.buildTraceabilityMap)(frs);
+        for (let i = 1; i < map.length; i++) {
+            assert.ok(map[i - 1].frId < map[i].frId);
+        }
+    });
+    (0, node_test_1.it)('FR with multiple journey sources shows all references', () => {
+        const j1 = makeValidJourney({
+            id: 'J-001',
+            steps: [makeStep(1, 'Shared action'), makeStep(2, 'B'), makeStep(3, 'C'), makeStep(4, 'D'), makeStep(5, 'E')],
+        });
+        const j2 = makeValidJourney({
+            id: 'J-002',
+            steps: [makeStep(1, 'Shared action'), makeStep(2, 'F'), makeStep(3, 'G'), makeStep(4, 'H'), makeStep(5, 'I')],
+        });
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)([j1, j2]);
+        const map = (0, specify_journeys_js_1.buildTraceabilityMap)(frs);
+        const sharedEntry = map.find((e) => e.description === 'Shared action');
+        assert.ok(sharedEntry);
+        assert.strictEqual(sharedEntry.journeyRefs.length, 2);
+        assert.ok(sharedEntry.journeyRefs.some((r) => r.includes('J-001')));
+        assert.ok(sharedEntry.journeyRefs.some((r) => r.includes('J-002')));
+    });
+});
+// ─── validateFRCoverage ──────────────────────────────────────────────────────
+(0, node_test_1.describe)('validateFRCoverage', () => {
+    (0, node_test_1.it)('valid extraction passes coverage check', () => {
+        const journeys = [makeValidJourney()];
+        const frs = (0, specify_journeys_js_1.extractFRsFromJourneys)(journeys);
+        const result = (0, specify_journeys_js_1.validateFRCoverage)(journeys, frs);
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.errors.length, 0);
+    });
+    (0, node_test_1.it)('journey with step having no FR fails', () => {
+        const journeys = [makeValidJourney()];
+        // Don't run extraction — steps have empty frIds
+        const frs = [];
+        const result = (0, specify_journeys_js_1.validateFRCoverage)(journeys, frs);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('no FR coverage')));
+    });
+    (0, node_test_1.it)('FR with no source journey fails', () => {
+        const orphanFr = {
+            id: 'FR-999',
+            description: 'Orphan',
+            scope: 'v1',
+            priority: 'P0',
+            sourceJourneys: [],
+            sourceSteps: [],
+        };
+        const result = (0, specify_journeys_js_1.validateFRCoverage)([], [orphanFr]);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('orphan FR')));
+    });
+    (0, node_test_1.it)('invalid FR ID format fails', () => {
+        const badFr = {
+            id: 'INVALID',
+            description: 'Bad ID',
+            scope: 'v1',
+            priority: 'P0',
+            sourceJourneys: ['J-001'],
+            sourceSteps: ['J-001 step 1'],
+        };
+        const result = (0, specify_journeys_js_1.validateFRCoverage)([], [badFr]);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('Invalid FR ID')));
+    });
+    (0, node_test_1.it)('invalid scope tag fails', () => {
+        const badFr = {
+            id: 'FR-001',
+            description: 'Bad scope',
+            scope: 'invalid',
+            priority: 'P0',
+            sourceJourneys: ['J-001'],
+            sourceSteps: ['J-001 step 1'],
+        };
+        const result = (0, specify_journeys_js_1.validateFRCoverage)([], [badFr]);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('invalid scope')));
+    });
+});

package/dist/tests/specify-nfr.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Specify NFR module tests — NFR categories, generation, validation
+ */
+export {};

package/dist/tests/specify-nfr.test.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Specify NFR module tests — NFR categories, generation, validation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const specify_nfr_js_1 = require("../lib/specify-nfr.js");
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function makeSampleFRs() {
+    return [
+        { id: 'FR-001', description: 'User opens dashboard', scope: 'v1', priority: 'P0', sourceJourneys: ['J-001'], sourceSteps: ['J-001 step 1'] },
+        { id: 'FR-002', description: 'User clicks create', scope: 'v1', priority: 'P0', sourceJourneys: ['J-001'], sourceSteps: ['J-001 step 2'] },
+        { id: 'FR-003', description: 'User fills form', scope: 'v1', priority: 'P1', sourceJourneys: ['J-001'], sourceSteps: ['J-001 step 3'] },
+        { id: 'FR-004', description: 'User views settings', scope: 'v1', priority: 'P1', sourceJourneys: ['J-004'], sourceSteps: ['J-004 step 1'] },
+        { id: 'FR-005', description: 'Future feature', scope: 'v2', priority: 'P2', sourceJourneys: ['J-004'], sourceSteps: ['J-004 step 2'] },
+    ];
+}
+// ─── NFR_CATEGORIES constant ────────────────────────────────────────────────
+(0, node_test_1.describe)('NFR_CATEGORIES', () => {
+    (0, node_test_1.it)('has exactly 4 entries', () => {
+        assert.strictEqual(specify_nfr_js_1.NFR_CATEGORIES.length, 4);
+    });
+    (0, node_test_1.it)('contains security, privacy, performance, observability', () => {
+        const cats = specify_nfr_js_1.NFR_CATEGORIES.map((c) => c.category);
+        assert.ok(cats.includes('security'));
+        assert.ok(cats.includes('privacy'));
+        assert.ok(cats.includes('performance'));
+        assert.ok(cats.includes('observability'));
+    });
+    (0, node_test_1.it)('each has non-empty description', () => {
+        for (const entry of specify_nfr_js_1.NFR_CATEGORIES) {
+            assert.ok(entry.description.length > 0, `${entry.category} has empty description`);
+        }
+    });
+});
+// ─── generateNFRs ───────────────────────────────────────────────────────────
+(0, node_test_1.describe)('generateNFRs', () => {
+    (0, node_test_1.it)('produces NFRs in all 4 categories', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        const cats = new Set(nfrs.map((n) => n.category));
+        assert.ok(cats.has('security'));
+        assert.ok(cats.has('privacy'));
+        assert.ok(cats.has('performance'));
+        assert.ok(cats.has('observability'));
+    });
+    (0, node_test_1.it)('NFR IDs are sequential: NFR-001, NFR-002, etc.', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        for (let i = 0; i < nfrs.length; i++) {
+            const expected = `NFR-${String(i + 1).padStart(3, '0')}`;
+            assert.strictEqual(nfrs[i].id, expected);
+        }
+    });
+    (0, node_test_1.it)('security NFRs include input validation NFR', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        const securityNfrs = nfrs.filter((n) => n.category === 'security');
+        assert.ok(securityNfrs.some((n) => n.description.toLowerCase().includes('input')));
+    });
+    (0, node_test_1.it)('privacy NFRs include data handling NFR', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        const privacyNfrs = nfrs.filter((n) => n.category === 'privacy');
+        assert.ok(privacyNfrs.some((n) => n.description.toLowerCase().includes('data')));
+    });
+    (0, node_test_1.it)('performance NFRs include response time with < 2s threshold', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        const perfNfrs = nfrs.filter((n) => n.category === 'performance');
+        assert.ok(perfNfrs.some((n) => n.threshold.includes('2s')));
+    });
+    (0, node_test_1.it)('observability NFRs include error tracking NFR', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        const obsNfrs = nfrs.filter((n) => n.category === 'observability');
+        assert.ok(obsNfrs.some((n) => n.description.toLowerCase().includes('error')));
+    });
+    (0, node_test_1.it)('NFRs linked to relevant FRs (v1 FRs linked to security)', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        const inputValidation = nfrs.find((n) => n.description.includes('input'));
+        assert.ok(inputValidation);
+        // Should link to v1 FRs
+        assert.ok(inputValidation.linkedFRs.includes('FR-001'));
+        assert.ok(inputValidation.linkedFRs.includes('FR-004'));
+        // Should NOT include v2 FRs
+        assert.ok(!inputValidation.linkedFRs.includes('FR-005'));
+    });
+    (0, node_test_1.it)('empty FR list still produces base NFRs', () => {
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)([]);
+        assert.ok(nfrs.length > 0);
+        const cats = new Set(nfrs.map((n) => n.category));
+        assert.ok(cats.has('security'));
+        assert.ok(cats.has('privacy'));
+        assert.ok(cats.has('performance'));
+        assert.ok(cats.has('observability'));
+    });
+    (0, node_test_1.it)('all thresholds are non-empty measurable strings', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        for (const nfr of nfrs) {
+            assert.ok(nfr.threshold.length > 0, `NFR ${nfr.id} has empty threshold`);
+        }
+    });
+});
+// ─── validateNFRs ───────────────────────────────────────────────────────────
+(0, node_test_1.describe)('validateNFRs', () => {
+    (0, node_test_1.it)('valid NFR set passes', () => {
+        const frs = makeSampleFRs();
+        const nfrs = (0, specify_nfr_js_1.generateNFRs)(frs);
+        const result = (0, specify_nfr_js_1.validateNFRs)(nfrs);
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.errors.length, 0);
+    });
+    (0, node_test_1.it)('missing security category fails', () => {
+        const nfrs = [
+            { id: 'NFR-001', category: 'privacy', description: 'Desc', threshold: 'Threshold', linkedFRs: ['FR-001'] },
+            { id: 'NFR-002', category: 'performance', description: 'Desc', threshold: 'Threshold', linkedFRs: ['FR-001'] },
+            { id: 'NFR-003', category: 'observability', description: 'Desc', threshold: 'Threshold', linkedFRs: ['FR-001'] },
+        ];
+        const result = (0, specify_nfr_js_1.validateNFRs)(nfrs);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('security')));
+    });
+    (0, node_test_1.it)('missing privacy category fails', () => {
+        const nfrs = [
+            { id: 'NFR-001', category: 'security', description: 'Desc', threshold: 'Threshold', linkedFRs: ['FR-001'] },
+            { id: 'NFR-002', category: 'performance', description: 'Desc', threshold: 'Threshold', linkedFRs: ['FR-001'] },
+            { id: 'NFR-003', category: 'observability', description: 'Desc', threshold: 'Threshold', linkedFRs: ['FR-001'] },
+        ];
+        const result = (0, specify_nfr_js_1.validateNFRs)(nfrs);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('privacy')));
+    });
+    (0, node_test_1.it)('NFR with invalid ID format fails', () => {
+        const nfrs = [
+            { id: 'INVALID', category: 'security', description: 'Desc', threshold: 'Threshold', linkedFRs: ['FR-001'] },
+        ];
+        const result = (0, specify_nfr_js_1.validateNFRs)(nfrs);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('Invalid NFR ID')));
+    });
+    (0, node_test_1.it)('NFR with empty description fails', () => {
+        const nfrs = [
+            { id: 'NFR-001', category: 'security', description: '', threshold: 'Threshold', linkedFRs: ['FR-001'] },
+        ];
+        const result = (0, specify_nfr_js_1.validateNFRs)(nfrs);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('empty description')));
+    });
+    (0, node_test_1.it)('NFR with empty threshold fails', () => {
+        const nfrs = [
+            { id: 'NFR-001', category: 'security', description: 'Desc', threshold: '', linkedFRs: ['FR-001'] },
+        ];
+        const result = (0, specify_nfr_js_1.validateNFRs)(nfrs);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('empty threshold')));
+    });
+    (0, node_test_1.it)('non-sequential IDs produce error', () => {
+        const nfrs = [
+            { id: 'NFR-001', category: 'security', description: 'Desc', threshold: 'T', linkedFRs: [] },
+            { id: 'NFR-003', category: 'privacy', description: 'Desc', threshold: 'T', linkedFRs: [] },
+            { id: 'NFR-004', category: 'performance', description: 'Desc', threshold: 'T', linkedFRs: [] },
+            { id: 'NFR-005', category: 'observability', description: 'Desc', threshold: 'T', linkedFRs: [] },
+        ];
+        const result = (0, specify_nfr_js_1.validateNFRs)(nfrs);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some((e) => e.includes('Non-sequential')));
+    });
+});

package/dist/tests/specify-roles.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Specify Roles module tests — Default config, auto mode, formatting
+ */
+export {};