@lumenflow/cli 2.20.1 → 2.21.1

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

@@ -1,121 +0,0 @@
-/**
- * @file wu-create.test.ts
- * Tests for wu:create helpers and warnings (WU-1429)
- */
-import { describe, it, expect } from 'vitest';
-import { buildWUContent, collectInitiativeWarnings, validateCreateSpec } from '../wu-create.js';
-const BASE_WU = {
-    id: 'WU-1429',
-    lane: 'Framework: CLI',
-    title: 'Test WU',
-    priority: 'P2',
-    type: 'feature',
-    created: '2026-02-04',
-    opts: {
-        description: 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum.',
-        acceptance: ['Acceptance criterion'],
-        exposure: 'backend-only',
-        codePaths: ['packages/@lumenflow/cli/src/wu-create.ts'],
-        testPathsUnit: ['packages/@lumenflow/cli/src/__tests__/wu-create.test.ts'],
-        specRefs: ['lumenflow://plans/WU-1429-plan.md'],
-    },
-};
-describe('wu:create helpers (WU-1429)', () => {
-    it('should default notes to non-empty placeholder when not provided', () => {
-        const wu = buildWUContent({
-            ...BASE_WU,
-            opts: {
-                ...BASE_WU.opts,
-                // Intentionally omit notes
-                notes: undefined,
-            },
-        });
-        expect(typeof wu.notes).toBe('string');
-        expect(wu.notes.trim().length).toBeGreaterThan(0);
-        expect(wu.notes).toContain('(auto)');
-    });
-    it('should persist notes when provided', () => {
-        const wu = buildWUContent({
-            ...BASE_WU,
-            opts: {
-                ...BASE_WU.opts,
-                notes: 'Implementation notes for test',
-            },
-        });
-        expect(wu.notes).toBe('Implementation notes for test');
-    });
-    it('should allow creating a plan-first WU without explicit test flags when code_paths are non-code', () => {
-        const validation = validateCreateSpec({
-            id: 'WU-2000',
-            lane: 'Framework: CLI',
-            title: 'Plan-only spec creation',
-            priority: 'P2',
-            type: 'feature',
-            opts: {
-                description: 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum.',
-                acceptance: ['Acceptance criterion'],
-                exposure: 'backend-only',
-                // Non-code file path: manual-only tests are acceptable.
-                codePaths: ['docs/README.md'],
-                // No testPathsManual/unit/e2e provided - should auto-default manual stub.
-                specRefs: ['lumenflow://plans/WU-2000-plan.md'],
-                strict: false,
-            },
-        });
-        expect(validation.valid).toBe(true);
-        const wu = buildWUContent({
-            id: 'WU-2000',
-            lane: 'Framework: CLI',
-            title: 'Plan-only spec creation',
-            priority: 'P2',
-            type: 'feature',
-            created: '2026-02-05',
-            opts: {
-                description: 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum.',
-                acceptance: ['Acceptance criterion'],
-                exposure: 'backend-only',
-                codePaths: ['docs/README.md'],
-                specRefs: ['lumenflow://plans/WU-2000-plan.md'],
-            },
-        });
-        expect(wu.tests?.manual?.length).toBeGreaterThan(0);
-    });
-    it('should warn when initiative has phases but no --phase is provided', () => {
-        const warnings = collectInitiativeWarnings({
-            initiativeId: 'INIT-TEST',
-            initiativeDoc: {
-                phases: [{ id: 1, title: 'Phase 1' }],
-            },
-            phase: undefined,
-            specRefs: ['lumenflow://plans/WU-1429-plan.md'],
-        });
-        expect(warnings).toEqual(expect.arrayContaining([
-            'Initiative INIT-TEST has phases defined. Consider adding --phase to link this WU to a phase.',
-        ]));
-    });
-    it('should warn when initiative has related_plan but no spec_refs', () => {
-        const warnings = collectInitiativeWarnings({
-            initiativeId: 'INIT-TEST',
-            initiativeDoc: {
-                related_plan: 'lumenflow://plans/INIT-TEST-plan.md',
-            },
-            phase: '1',
-            specRefs: [],
-        });
-        expect(warnings).toEqual(expect.arrayContaining([
-            'Initiative INIT-TEST has related_plan (lumenflow://plans/INIT-TEST-plan.md). Consider adding --spec-refs to link this WU to the plan.',
-        ]));
-    });
-    it('should not warn when phase and spec_refs are provided', () => {
-        const warnings = collectInitiativeWarnings({
-            initiativeId: 'INIT-TEST',
-            initiativeDoc: {
-                phases: [{ id: 1, title: 'Phase 1' }],
-                related_plan: 'lumenflow://plans/INIT-TEST-plan.md',
-            },
-            phase: '1',
-            specRefs: ['lumenflow://plans/WU-1429-plan.md'],
-        });
-        expect(warnings).toEqual([]);
-    });
-});

package/dist/__tests__/wu-done-auto-cleanup.test.js

@@ -1,135 +0,0 @@
-/**
- * @file wu-done-auto-cleanup.test.ts
- * Test suite for wu:done auto cleanup on success (WU-1366)
- *
- * WU-1366: State cleanup runs automatically after wu:done success (non-fatal)
- *
- * Tests:
- * - shouldRunAutoCleanup respects config.cleanup.trigger setting
- * - runAutoCleanupAfterDone is non-fatal (logs errors but doesn't throw)
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-/** Common mock path for lumenflow config module */
-const CONFIG_MODULE_PATH = '@lumenflow/core/dist/lumenflow-config.js';
-// Test the exported functions directly with minimal mocking
-describe('wu:done auto cleanup (WU-1366)', () => {
-    let consoleLogSpy;
-    let consoleWarnSpy;
-    beforeEach(() => {
-        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        consoleLogSpy.mockRestore();
-        consoleWarnSpy.mockRestore();
-        vi.resetModules();
-    });
-    describe('shouldRunAutoCleanup', () => {
-        it('should return true when config.cleanup.trigger is on_done', async () => {
-            // Mock getConfig to return on_done trigger
-            vi.doMock(CONFIG_MODULE_PATH, () => ({
-                getConfig: vi.fn().mockReturnValue({
-                    cleanup: { trigger: 'on_done' },
-                }),
-            }));
-            const { shouldRunAutoCleanup } = await import('../wu-done-auto-cleanup.js');
-            const result = shouldRunAutoCleanup();
-            expect(result).toBe(true);
-        });
-        it('should return false when config.cleanup.trigger is manual', async () => {
-            vi.doMock(CONFIG_MODULE_PATH, () => ({
-                getConfig: vi.fn().mockReturnValue({
-                    cleanup: { trigger: 'manual' },
-                }),
-            }));
-            const { shouldRunAutoCleanup } = await import('../wu-done-auto-cleanup.js');
-            const result = shouldRunAutoCleanup();
-            expect(result).toBe(false);
-        });
-        it('should return false when config.cleanup.trigger is on_init', async () => {
-            vi.doMock(CONFIG_MODULE_PATH, () => ({
-                getConfig: vi.fn().mockReturnValue({
-                    cleanup: { trigger: 'on_init' },
-                }),
-            }));
-            const { shouldRunAutoCleanup } = await import('../wu-done-auto-cleanup.js');
-            const result = shouldRunAutoCleanup();
-            expect(result).toBe(false);
-        });
-        it('should return true when cleanup config is missing (default behavior)', async () => {
-            vi.doMock(CONFIG_MODULE_PATH, () => ({
-                getConfig: vi.fn().mockReturnValue({}),
-            }));
-            const { shouldRunAutoCleanup } = await import('../wu-done-auto-cleanup.js');
-            const result = shouldRunAutoCleanup();
-            expect(result).toBe(true);
-        });
-    });
-    describe('runAutoCleanupAfterDone non-fatal behavior', () => {
-        it('should not throw when cleanup throws an error', async () => {
-            // Mock config to enable cleanup
-            vi.doMock(CONFIG_MODULE_PATH, () => ({
-                getConfig: vi.fn().mockReturnValue({
-                    cleanup: { trigger: 'on_done' },
-                    directories: { wuDir: 'docs/tasks/wu' },
-                }),
-            }));
-            // Mock cleanupState to throw
-            vi.doMock('@lumenflow/core/dist/state-cleanup-core.js', () => ({
-                cleanupState: vi.fn().mockRejectedValue(new Error('Cleanup failed')),
-            }));
-            // Mock the memory functions to avoid actual file operations
-            vi.doMock('@lumenflow/memory/dist/signal-cleanup-core.js', () => ({
-                cleanupSignals: vi.fn().mockResolvedValue({
-                    success: true,
-                    removedIds: [],
-                    retainedIds: [],
-                    bytesFreed: 0,
-                    compactionRatio: 0,
-                    breakdown: {},
-                }),
-            }));
-            vi.doMock('@lumenflow/memory/dist/mem-cleanup-core.js', () => ({
-                cleanupMemory: vi.fn().mockResolvedValue({
-                    success: true,
-                    removedIds: [],
-                    retainedIds: [],
-                    bytesFreed: 0,
-                    compactionRatio: 0,
-                    breakdown: {},
-                }),
-            }));
-            vi.doMock('@lumenflow/core/dist/wu-events-cleanup.js', () => ({
-                archiveWuEvents: vi.fn().mockResolvedValue({
-                    success: true,
-                    archivedWuIds: [],
-                    retainedWuIds: [],
-                    bytesArchived: 0,
-                    archivedEventCount: 0,
-                    retainedEventCount: 0,
-                    breakdown: {},
-                }),
-            }));
-            const { runAutoCleanupAfterDone } = await import('../wu-done-auto-cleanup.js');
-            // Should not throw - cleanup errors are non-fatal
-            await expect(runAutoCleanupAfterDone('/test/dir')).resolves.not.toThrow();
-            // Should log warning about the error
-            expect(consoleWarnSpy).toHaveBeenCalled();
-        });
-        it('should skip cleanup when trigger is manual', async () => {
-            vi.doMock(CONFIG_MODULE_PATH, () => ({
-                getConfig: vi.fn().mockReturnValue({
-                    cleanup: { trigger: 'manual' },
-                }),
-            }));
-            const mockCleanupState = vi.fn();
-            vi.doMock('@lumenflow/core/dist/state-cleanup-core.js', () => ({
-                cleanupState: mockCleanupState,
-            }));
-            const { runAutoCleanupAfterDone } = await import('../wu-done-auto-cleanup.js');
-            await runAutoCleanupAfterDone('/test/dir');
-            // Cleanup should not be called when trigger is manual
-            expect(mockCleanupState).not.toHaveBeenCalled();
-        });
-    });
-});

package/dist/__tests__/wu-done-docs-only-policy.test.js

@@ -1,20 +0,0 @@
-/**
- * @file wu-done-docs-only-policy.test.ts
- * Guardrail test: docs-only eligibility checks must not use raw type/exposure string literals (WU-1446).
- *
- * This keeps CLI policy logic DRY and aligned with core constants/helpers.
- */
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-describe('wu:done docs-only policy (WU-1446)', () => {
-    it('should not use raw documentation string comparisons for type/exposure checks', () => {
-        const thisDir = path.dirname(fileURLToPath(import.meta.url));
-        const filePath = path.join(thisDir, '..', 'wu-done.ts');
-        const content = readFileSync(filePath, 'utf-8');
-        // These comparisons should use core constants/helpers instead.
-        expect(content).not.toContain("exposure === 'documentation'");
-        expect(content).not.toContain("type === 'documentation'");
-    });
-});

package/dist/__tests__/wu-done-staging-whitelist.test.js

@@ -1,35 +0,0 @@
-/**
- * @file Tests for wu-done staging whitelist patterns
- * @see WU-1072: Fix staging whitelist for auto-generated docs
- */
-import { describe, it, expect } from 'vitest';
-/**
- * Pattern matching logic extracted from validateStagedFiles in wu-done.ts
- * This tests the MDX whitelist pattern added in WU-1072
- */
-function isWhitelistedAutoGeneratedDoc(file) {
-    return file.startsWith('apps/docs/') && file.endsWith('.mdx');
-}
-describe('wu-done staging whitelist', () => {
-    describe('auto-generated docs pattern (WU-1072)', () => {
-        it('should whitelist MDX files in apps/docs/', () => {
-            expect(isWhitelistedAutoGeneratedDoc('apps/docs/api/wu-create.mdx')).toBe(true);
-            expect(isWhitelistedAutoGeneratedDoc('apps/docs/commands/gates.mdx')).toBe(true);
-            expect(isWhitelistedAutoGeneratedDoc('apps/docs/nested/deep/file.mdx')).toBe(true);
-        });
-        it('should not whitelist MDX files outside apps/docs/', () => {
-            expect(isWhitelistedAutoGeneratedDoc('docs/something.mdx')).toBe(false);
-            expect(isWhitelistedAutoGeneratedDoc('packages/cli/README.mdx')).toBe(false);
-            expect(isWhitelistedAutoGeneratedDoc('src/docs/file.mdx')).toBe(false);
-        });
-        it('should not whitelist non-MDX files in apps/docs/', () => {
-            expect(isWhitelistedAutoGeneratedDoc('apps/docs/config.ts')).toBe(false);
-            expect(isWhitelistedAutoGeneratedDoc('apps/docs/package.json')).toBe(false);
-            expect(isWhitelistedAutoGeneratedDoc('apps/docs/styles.css')).toBe(false);
-        });
-        it('should not whitelist files with mdx in the path but not as extension', () => {
-            expect(isWhitelistedAutoGeneratedDoc('apps/docs/mdx-utils/helper.ts')).toBe(false);
-            expect(isWhitelistedAutoGeneratedDoc('apps/docs/mdx')).toBe(false);
-        });
-    });
-});

package/dist/__tests__/wu-done.test.js

@@ -1,36 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ensureCleanWorktree } from '../wu-done-check.js';
-import * as gitAdapter from '@lumenflow/core/git-adapter';
-import * as errorHandler from '@lumenflow/core/error-handler';
-// Mock dependencies
-vi.mock('@lumenflow/core/git-adapter');
-vi.mock('@lumenflow/core/error-handler');
-describe('wu-done', () => {
-    describe('ensureCleanWorktree', () => {
-        let mockGit;
-        beforeEach(() => {
-            vi.resetAllMocks();
-            mockGit = {
-                getStatus: vi.fn(),
-            };
-            vi.mocked(gitAdapter.createGitForPath).mockReturnValue(mockGit);
-        });
-        it('should pass if worktree is clean', async () => {
-            mockGit.getStatus.mockResolvedValue(''); // Clean status
-            await ensureCleanWorktree('/path/to/worktree');
-            expect(mockGit.getStatus).toHaveBeenCalled();
-            expect(errorHandler.die).not.toHaveBeenCalled();
-        });
-        it('should die if worktree has uncommitted changes', async () => {
-            mockGit.getStatus.mockResolvedValue('M  file.ts\n?? new-file.ts'); // Dirty status
-            await ensureCleanWorktree('/path/to/worktree');
-            expect(mockGit.getStatus).toHaveBeenCalled();
-            expect(errorHandler.die).toHaveBeenCalledWith(expect.stringContaining('Worktree has uncommitted changes'));
-        });
-        it('should use the correct worktree path', async () => {
-            mockGit.getStatus.mockResolvedValue('');
-            await ensureCleanWorktree('/custom/worktree/path');
-            expect(gitAdapter.createGitForPath).toHaveBeenCalledWith('/custom/worktree/path');
-        });
-    });
-});

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

@@ -1,109 +0,0 @@
-/**
- * @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-edit.test.js

@@ -1,119 +0,0 @@
-/**
- * WU-1225: Tests for wu-edit append-by-default behavior
- *
- * Validates that array fields (code_paths, risks, acceptance, etc.)
- * now append by default instead of replacing, making behavior consistent
- * across all array options.
- */
-import { describe, it, expect } from 'vitest';
-import { applyEdits, mergeStringField } from '../wu-edit.js';
-describe('wu-edit applyEdits', () => {
-    describe('WU-1225: code_paths append-by-default', () => {
-        const baseWU = {
-            id: 'WU-1225',
-            status: 'ready',
-            code_paths: ['existing/path.ts'],
-        };
-        it('appends code_paths by default (no flags)', () => {
-            const opts = { codePaths: ['new/path.ts'] };
-            const result = applyEdits(baseWU, opts);
-            expect(result.code_paths).toEqual(['existing/path.ts', 'new/path.ts']);
-        });
-        it('appends code_paths when --append is set (backwards compat)', () => {
-            const opts = { codePaths: ['new/path.ts'], append: true };
-            const result = applyEdits(baseWU, opts);
-            expect(result.code_paths).toEqual(['existing/path.ts', 'new/path.ts']);
-        });
-        it('replaces code_paths when --replace-code-paths is set', () => {
-            const opts = { codePaths: ['new/path.ts'], replaceCodePaths: true };
-            const result = applyEdits(baseWU, opts);
-            expect(result.code_paths).toEqual(['new/path.ts']);
-        });
-    });
-    describe('WU-1225: risks append-by-default', () => {
-        const baseWU = {
-            id: 'WU-1225',
-            status: 'ready',
-            risks: ['existing risk'],
-        };
-        it('appends risks by default', () => {
-            const opts = { risks: ['new risk'] };
-            const result = applyEdits(baseWU, opts);
-            expect(result.risks).toEqual(['existing risk', 'new risk']);
-        });
-        it('replaces risks when --replace-risks is set', () => {
-            const opts = { risks: ['new risk'], replaceRisks: true };
-            const result = applyEdits(baseWU, opts);
-            expect(result.risks).toEqual(['new risk']);
-        });
-    });
-    describe('WU-1225: blocked_by append-by-default', () => {
-        const baseWU = {
-            id: 'WU-1225',
-            status: 'ready',
-            blocked_by: ['WU-100'],
-        };
-        it('appends blocked_by by default', () => {
-            const opts = { blockedBy: 'WU-200' };
-            const result = applyEdits(baseWU, opts);
-            expect(result.blocked_by).toEqual(['WU-100', 'WU-200']);
-        });
-        it('replaces blocked_by when --replace-blocked-by is set', () => {
-            const opts = { blockedBy: 'WU-200', replaceBlockedBy: true };
-            const result = applyEdits(baseWU, opts);
-            expect(result.blocked_by).toEqual(['WU-200']);
-        });
-    });
-    describe('WU-1225: dependencies append-by-default', () => {
-        const baseWU = {
-            id: 'WU-1225',
-            status: 'ready',
-            dependencies: ['WU-50'],
-        };
-        it('appends dependencies by default', () => {
-            const opts = { addDep: 'WU-60' };
-            const result = applyEdits(baseWU, opts);
-            expect(result.dependencies).toEqual(['WU-50', 'WU-60']);
-        });
-        it('replaces dependencies when --replace-dependencies is set', () => {
-            const opts = { addDep: 'WU-60', replaceDependencies: true };
-            const result = applyEdits(baseWU, opts);
-            expect(result.dependencies).toEqual(['WU-60']);
-        });
-    });
-    describe('WU-1144: acceptance already appends by default', () => {
-        const baseWU = {
-            id: 'WU-1225',
-            status: 'ready',
-            acceptance: ['existing criterion'],
-        };
-        it('appends acceptance by default', () => {
-            const opts = { acceptance: ['new criterion'] };
-            const result = applyEdits(baseWU, opts);
-            expect(result.acceptance).toEqual(['existing criterion', 'new criterion']);
-        });
-        it('replaces acceptance when --replace-acceptance is set', () => {
-            const opts = { acceptance: ['new criterion'], replaceAcceptance: true };
-            const result = applyEdits(baseWU, opts);
-            expect(result.acceptance).toEqual(['new criterion']);
-        });
-    });
-});
-describe('wu-edit mergeStringField', () => {
-    it('appends by default', () => {
-        const result = mergeStringField('existing', 'new', false);
-        expect(result).toBe('existing\n\nnew');
-    });
-    it('replaces when shouldReplace is true', () => {
-        const result = mergeStringField('existing', 'new', true);
-        expect(result).toBe('new');
-    });
-    it('returns new value if existing is empty', () => {
-        const result = mergeStringField('', 'new', false);
-        expect(result).toBe('new');
-    });
-    it('returns new value if existing is undefined', () => {
-        const result = mergeStringField(undefined, 'new', false);
-        expect(result).toBe('new');
-    });
-});