@lumenflow/cli 2.4.0 → 2.5.1

package/dist/__tests__/wu-create-strict.test.js

@@ -0,0 +1,118 @@
+/**
+ * @file wu-create-strict.test.ts
+ * Test suite for wu:create strict validation behavior (WU-1329)
+ *
+ * WU-1329: Make wu:create run strict validation by default
+ *
+ * Tests:
+ * - Strict validation runs by default (validates code_paths/test_paths exist)
+ * - --no-strict flag bypasses strict validation
+ * - --no-strict usage is logged
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// Import test utilities (WU-1329)
+import { validateCreateSpec } from '../wu-create.js';
+// WU-1329: Constants for test file paths
+const NON_EXISTENT_CODE_PATH = 'non-existent/file.ts';
+const NON_EXISTENT_TEST_PATH = 'non-existent/test.test.ts';
+describe('wu:create strict validation (WU-1329)', () => {
+    describe('validateCreateSpec strict mode', () => {
+        const baseOpts = {
+            id: 'WU-9999',
+            lane: 'Framework: CLI',
+            title: 'Test WU',
+            priority: 'P2',
+            type: 'feature',
+            opts: {
+                description: 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum length requirement.',
+                acceptance: ['Acceptance criterion 1'],
+                codePaths: ['packages/@lumenflow/cli/src/wu-create.ts'],
+                testPathsUnit: ['packages/@lumenflow/cli/src/__tests__/wu-create-strict.test.ts'],
+                exposure: 'backend-only',
+                specRefs: ['lumenflow://plans/WU-9999-plan.md'],
+            },
+        };
+        it('should pass validation with valid spec in non-strict mode', () => {
+            const result = validateCreateSpec({
+                ...baseOpts,
+                opts: {
+                    ...baseOpts.opts,
+                    strict: false,
+                },
+            });
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        // WU-1329: This test verifies that strict validation is the default
+        it('should validate code_paths existence by default (strict=true)', () => {
+            const result = validateCreateSpec({
+                ...baseOpts,
+                opts: {
+                    ...baseOpts.opts,
+                    codePaths: [NON_EXISTENT_CODE_PATH],
+                    // strict is not explicitly set - should default to true
+                },
+            });
+            // In strict mode, non-existent paths should be caught
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes('code_paths') || e.includes('not found'))).toBe(true);
+        });
+        // WU-1329: This test verifies --no-strict bypasses path validation
+        it('should skip code_paths existence check when strict=false', () => {
+            const result = validateCreateSpec({
+                ...baseOpts,
+                opts: {
+                    ...baseOpts.opts,
+                    codePaths: [NON_EXISTENT_CODE_PATH],
+                    strict: false,
+                },
+            });
+            // In non-strict mode, non-existent paths should not fail validation
+            // (other schema validation may still fail)
+            expect(result.errors.every((e) => !e.includes('not found') && !e.includes('does not exist'))).toBe(true);
+        });
+        // WU-1329: This test verifies test_paths validation in strict mode
+        it('should validate test_paths existence by default (strict=true)', () => {
+            const result = validateCreateSpec({
+                ...baseOpts,
+                opts: {
+                    ...baseOpts.opts,
+                    testPathsUnit: [NON_EXISTENT_TEST_PATH],
+                },
+            });
+            // In strict mode, non-existent test paths should be caught
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes('test') || e.includes('not found'))).toBe(true);
+        });
+    });
+    describe('--no-strict logging', () => {
+        let consoleSpy;
+        beforeEach(() => {
+            consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            consoleSpy.mockRestore();
+        });
+        // WU-1329: This test verifies --no-strict usage is logged
+        it('should log warning when --no-strict is used', () => {
+            validateCreateSpec({
+                id: 'WU-9999',
+                lane: 'Framework: CLI',
+                title: 'Test WU',
+                priority: 'P2',
+                type: 'feature',
+                opts: {
+                    description: 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum.',
+                    acceptance: ['Acceptance criterion'],
+                    codePaths: [NON_EXISTENT_CODE_PATH],
+                    testPathsUnit: [NON_EXISTENT_TEST_PATH],
+                    exposure: 'backend-only',
+                    specRefs: ['lumenflow://plans/WU-9999-plan.md'],
+                    strict: false,
+                },
+            });
+            // Should log that strict validation was bypassed
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('strict validation bypassed'));
+        });
+    });
+});

package/dist/__tests__/wu-edit-strict.test.js

@@ -0,0 +1,109 @@
+/**
+ * @file wu-edit-strict.test.ts
+ * Test suite for wu:edit strict validation behavior (WU-1329)
+ *
+ * WU-1329: Make wu:edit run strict validation by default
+ *
+ * Tests:
+ * - applyEdits function works correctly (unit test for edit logic)
+ * - validateDoneWUEdits properly validates done WU edits
+ * - The main() function validates paths in strict mode (covered by e2e tests)
+ */
+import { describe, it, expect } from 'vitest';
+// Import test utilities (WU-1329)
+import { applyEdits, validateDoneWUEdits, validateExposureValue } from '../wu-edit.js';
+// WU-1329: Constants for test file paths
+const TEST_NEW_FILE_PATH = 'new/file.ts';
+const TEST_NEW_TEST_PATH = 'new/test.test.ts';
+describe('wu:edit strict validation (WU-1329)', () => {
+    describe('applyEdits code_paths handling', () => {
+        const baseWU = {
+            id: 'WU-9999',
+            title: 'Test WU',
+            lane: 'Framework: CLI',
+            type: 'feature',
+            status: 'ready',
+            priority: 'P2',
+            description: 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum length.',
+            acceptance: ['Existing criterion'],
+            code_paths: ['packages/@lumenflow/cli/src/wu-edit.ts'],
+            tests: {
+                unit: ['packages/@lumenflow/cli/src/__tests__/wu-edit-strict.test.ts'],
+                manual: [],
+                e2e: [],
+            },
+        };
+        // WU-1329: applyEdits transforms WU object - path validation is done separately
+        it('should apply code_paths edits correctly', () => {
+            const result = applyEdits(baseWU, {
+                codePaths: [TEST_NEW_FILE_PATH],
+                replaceCodePaths: true,
+            });
+            // applyEdits transforms the WU, validation happens later in main()
+            expect(result.code_paths).toContain(TEST_NEW_FILE_PATH);
+            expect(result.code_paths).toHaveLength(1);
+        });
+        it('should append code_paths by default', () => {
+            const result = applyEdits(baseWU, {
+                codePaths: [TEST_NEW_FILE_PATH],
+            });
+            expect(result.code_paths).toContain('packages/@lumenflow/cli/src/wu-edit.ts');
+            expect(result.code_paths).toContain(TEST_NEW_FILE_PATH);
+            expect(result.code_paths).toHaveLength(2);
+        });
+        it('should apply test_paths edits correctly', () => {
+            const result = applyEdits(baseWU, {
+                testPathsUnit: [TEST_NEW_TEST_PATH],
+            });
+            // Should append test paths
+            expect(result.tests.unit).toContain('packages/@lumenflow/cli/src/__tests__/wu-edit-strict.test.ts');
+            expect(result.tests.unit).toContain(TEST_NEW_TEST_PATH);
+        });
+    });
+    describe('validateDoneWUEdits', () => {
+        // WU-1329: Done WUs only allow initiative/phase/exposure edits
+        it('should allow exposure edits on done WUs', () => {
+            const result = validateDoneWUEdits({ exposure: 'backend-only' });
+            expect(result.valid).toBe(true);
+            expect(result.disallowedEdits).toHaveLength(0);
+        });
+        it('should disallow code_paths edits on done WUs', () => {
+            const result = validateDoneWUEdits({ codePaths: [TEST_NEW_FILE_PATH] });
+            expect(result.valid).toBe(false);
+            expect(result.disallowedEdits).toContain('--code-paths');
+        });
+        it('should disallow description edits on done WUs', () => {
+            const result = validateDoneWUEdits({ description: 'new description' });
+            expect(result.valid).toBe(false);
+            expect(result.disallowedEdits).toContain('--description');
+        });
+    });
+    describe('validateExposureValue', () => {
+        it('should accept valid exposure values', () => {
+            expect(validateExposureValue('ui').valid).toBe(true);
+            expect(validateExposureValue('api').valid).toBe(true);
+            expect(validateExposureValue('backend-only').valid).toBe(true);
+            expect(validateExposureValue('documentation').valid).toBe(true);
+        });
+        it('should reject invalid exposure values', () => {
+            const result = validateExposureValue('invalid-exposure');
+            expect(result.valid).toBe(false);
+            expect(result.error).toContain('Invalid exposure value');
+        });
+    });
+    describe('noStrict option support', () => {
+        // WU-1329: Verify CLI option parsing pattern
+        it('should support noStrict option in CLI argument pattern', () => {
+            // CLI uses --no-strict which Commander.js parses as noStrict
+            // The main() function converts this to strict: !noStrict
+            const cliArgs = { noStrict: true };
+            const strict = !cliArgs.noStrict;
+            expect(strict).toBe(false);
+        });
+        it('should default to strict=true when noStrict is undefined', () => {
+            const cliArgs = { noStrict: undefined };
+            const strict = !cliArgs.noStrict;
+            expect(strict).toBe(true);
+        });
+    });
+});

package/dist/__tests__/wu-validate-strict.test.js

@@ -0,0 +1,113 @@
+/**
+ * @file wu-validate-strict.test.ts
+ * Test suite for wu:validate strict validation behavior (WU-1329)
+ *
+ * WU-1329: Make wu:validate treat warnings as errors by default
+ *
+ * Tests:
+ * - Default strict mode behavior (warnings treated as errors)
+ * - --no-strict flag restores original behavior (warnings advisory)
+ * - Help text documents strict default
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { WU_OPTIONS, NEGATED_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
+describe('wu:validate strict validation (WU-1329)', () => {
+    describe('WU_OPTIONS.noStrict configuration', () => {
+        // WU-1329: Verify the noStrict option is properly configured
+        it('should have noStrict option defined in WU_OPTIONS', () => {
+            expect(WU_OPTIONS.noStrict).toBeDefined();
+            expect(WU_OPTIONS.noStrict.name).toBe('noStrict');
+            expect(WU_OPTIONS.noStrict.flags).toBe('--no-strict');
+            expect(WU_OPTIONS.noStrict.isNegated).toBe(true);
+        });
+        it('should include description about bypassing strict validation', () => {
+            expect(WU_OPTIONS.noStrict.description).toContain('Bypass strict validation');
+        });
+        // WU-1329: Verify 'strict' is in NEGATED_OPTIONS array
+        it('should include strict in NEGATED_OPTIONS array', () => {
+            expect(NEGATED_OPTIONS).toContain('strict');
+        });
+    });
+    describe('strict mode logic', () => {
+        // WU-1329: Verify the strict mode conversion pattern
+        it('should default to strict=true when noStrict is undefined', () => {
+            const args = { noStrict: undefined };
+            const strict = !args.noStrict;
+            expect(strict).toBe(true);
+        });
+        it('should set strict=false when noStrict is true (--no-strict flag)', () => {
+            const args = { noStrict: true };
+            const strict = !args.noStrict;
+            expect(strict).toBe(false);
+        });
+        it('should set strict=true when noStrict is false (explicit)', () => {
+            const args = { noStrict: false };
+            const strict = !args.noStrict;
+            expect(strict).toBe(true);
+        });
+    });
+    describe('--no-strict logging behavior', () => {
+        let consoleSpy;
+        beforeEach(() => {
+            consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            consoleSpy.mockRestore();
+        });
+        // WU-1329: The logging behavior is implemented in main() functions
+        // This test documents the expected behavior pattern using the spy
+        it('should log when --no-strict bypass is used', () => {
+            // Simulate the logging pattern from wu-validate.ts main()
+            const noStrict = true;
+            const LOG_PREFIX = '[wu:validate]';
+            const message = `${LOG_PREFIX} WARNING: strict validation bypassed (--no-strict). Warnings will be advisory only.`;
+            if (noStrict) {
+                // Use the spy to simulate logging
+                consoleSpy(message);
+            }
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('strict validation bypassed'));
+        });
+        it('should not log when strict mode is active', () => {
+            // When noStrict is false, no logging should occur
+            const noStrict = false;
+            if (noStrict) {
+                consoleSpy('This should not be called');
+            }
+            expect(consoleSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('validateSingleWU strict mode behavior', () => {
+        // WU-1329: These tests document the expected behavior
+        // The actual validation is done by calling the CLI command
+        it('should treat warnings as errors by default (strict=true)', () => {
+            // In strict mode, any warnings from completeness validation
+            // should become errors and cause validation to fail
+            const strict = true;
+            const warnings = ['Missing recommended field: notes'];
+            const errors = [];
+            if (strict && warnings.length > 0) {
+                errors.push(...warnings.map((w) => `[STRICT] ${w}`));
+            }
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0]).toContain('[STRICT]');
+        });
+        it('should allow warnings when strict=false (--no-strict)', () => {
+            // In non-strict mode, warnings should remain warnings
+            // and validation should pass
+            const strict = false;
+            const warnings = ['Missing recommended field: notes'];
+            const errors = [];
+            if (strict && warnings.length > 0) {
+                errors.push(...warnings.map((w) => `[STRICT] ${w}`));
+            }
+            expect(errors.length).toBe(0);
+        });
+    });
+    describe('help text documentation', () => {
+        // WU-1329: Verify help text documents strict default
+        it('should document that --no-strict bypasses strict validation', () => {
+            const expectedDescription = 'Bypass strict validation';
+            expect(WU_OPTIONS.noStrict.description).toContain(expectedDescription);
+        });
+    });
+});

package/dist/flow-bottlenecks.js

@@ -15,8 +15,9 @@
  */
 import { Command } from 'commander';
 import { getBottleneckAnalysis, } from '@lumenflow/metrics';
-import { buildDependencyGraphAsync, renderMermaid, } from '@lumenflow/core/dist/dependency-graph.js';
+import { buildDependencyGraphAsync, renderMermaid } from '@lumenflow/core/dist/dependency-graph.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 /** Log prefix for console output */
 const LOG_PREFIX = '[flow:bottlenecks]';
 /** Default bottleneck limit */
@@ -147,7 +148,8 @@ async function main() {
     const coreGraph = await buildDependencyGraphAsync();
     if (coreGraph.size === 0) {
         console.log(`${LOG_PREFIX} No WUs found in dependency graph.`);
-        console.log(`${LOG_PREFIX} Ensure WU YAML files exist in docs/04-operations/tasks/wu/ with blocked_by/blocks fields.`);
+        // WU-1311: Use config-based WU directory path
+        console.log(`${LOG_PREFIX} Ensure WU YAML files exist in ${getConfig().directories.wuDir}/ with blocked_by/blocks fields.`);
         return;
     }
     console.log(`${LOG_PREFIX} Found ${coreGraph.size} WUs in graph`);

package/dist/gates.js

@@ -68,6 +68,8 @@ import { runSystemMapValidation } from '@lumenflow/core/dist/system-map-validato
 import { loadLaneHealthConfig, resolveTestPolicy, } from '@lumenflow/core/dist/gates-config.js';
 // WU-1191: Lane health check
 import { runLaneHealthCheck } from './lane-health.js';
+// WU-1315: Onboarding smoke test
+import { runOnboardingSmokeTestGate } from './onboarding-smoke-test.js';
 import { BRANCHES, PACKAGES, PKG_MANAGER, ESLINT_FLAGS, ESLINT_COMMANDS, ESLINT_DEFAULTS, SCRIPTS, CACHE_STRATEGIES, DIRECTORIES, GATE_NAMES, GATE_COMMANDS, CLI_MODES, EXIT_CODES, FILE_SYSTEM, PRETTIER_ARGS, PRETTIER_FLAGS, } from '@lumenflow/core/dist/wu-constants.js';
 /**
  * WU-1087: Gates-specific option definitions for createWUParser.
@@ -1115,6 +1117,11 @@ async function executeGates(opts) {
                 run: (ctx) => runLaneHealthGate({ ...ctx, mode: laneHealthMode }),
                 warnOnly: laneHealthMode !== 'error',
             },
+            // WU-1315: Onboarding smoke test (init + wu:create validation)
+            {
+                name: GATE_NAMES.ONBOARDING_SMOKE_TEST,
+                cmd: GATE_COMMANDS.ONBOARDING_SMOKE_TEST,
+            },
             // WU-1299: Filtered tests for packages in code_paths (if any)
             // When docs-only mode has packages in code_paths, run tests only for those packages
             // This prevents pre-existing failures in unrelated packages from blocking
@@ -1163,6 +1170,11 @@ async function executeGates(opts) {
                 run: (ctx) => runLaneHealthGate({ ...ctx, mode: laneHealthMode }),
                 warnOnly: laneHealthMode !== 'error',
             },
+            // WU-1315: Onboarding smoke test (init + wu:create validation)
+            {
+                name: GATE_NAMES.ONBOARDING_SMOKE_TEST,
+                cmd: GATE_COMMANDS.ONBOARDING_SMOKE_TEST,
+            },
             // WU-2062: Safety-critical tests ALWAYS run
             // WU-1280: When tests_required=false (methodology.testing: none), failures only warn
             {
@@ -1285,6 +1297,16 @@ async function executeGates(opts) {
                     : console,
             });
         }
+        else if (gate.cmd === GATE_COMMANDS.ONBOARDING_SMOKE_TEST) {
+            // WU-1315: Onboarding smoke test (init + wu:create validation)
+            const logLine = useAgentMode
+                ? (line) => writeSync(agentLog.logFd, `${line}\n`)
+                : (line) => console.log(line);
+            logLine('\n> Onboarding smoke test\n');
+            result = await runOnboardingSmokeTestGate({
+                logger: { log: logLine },
+            });
+        }
         else {
             result = run(gate.cmd, { agentLog });
         }