@lumenflow/cli 2.4.0 → 2.5.1

package/dist/__tests__/path-centralization-cli.test.js

@@ -0,0 +1,234 @@
+/**
+ * @fileoverview Tests for WU-1311: CLI path centralization
+ *
+ * Tests that CLI commands use WU_PATHS/getResolvedPaths/getConfig
+ * instead of hardcoded 'docs/04-operations' paths.
+ *
+ * WU-1311 Acceptance Criteria:
+ * - No hardcoded docs/04-operations paths remain in CLI commands (use WU_PATHS/getResolvedPaths)
+ * - state-doctor warns when configured paths are missing
+ * - Config overrides are respected across wu-* commands and diagnostics
+ * - Unit tests cover CLI path usage and warnings
+ *
+ * @module __tests__/path-centralization-cli.test
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import * as yaml from 'yaml';
+import { clearConfigCache, getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
+import { WU_PATHS, createWuPaths } from '@lumenflow/core/dist/wu-paths.js';
+/** Config file name constant */
+const CONFIG_FILE = '.lumenflow.config.yaml';
+describe('WU-1311: CLI path centralization', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cli-path-test-'));
+        clearConfigCache();
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+        clearConfigCache();
+    });
+    describe('AC1: No hardcoded docs/04-operations paths in CLI commands', () => {
+        it('should use config-based paths for WU file path generation', () => {
+            const paths = createWuPaths({ projectRoot: tempDir });
+            // Paths should be from config, not hardcoded
+            expect(paths.WU('WU-1311')).toBe('docs/04-operations/tasks/wu/WU-1311.yaml');
+            expect(paths.STATUS()).toBe('docs/04-operations/tasks/status.md');
+            expect(paths.BACKLOG()).toBe('docs/04-operations/tasks/backlog.md');
+        });
+        it('should respect custom config paths for WU operations', async () => {
+            const customConfig = {
+                version: '1.0.0',
+                directories: {
+                    wuDir: 'custom/wu',
+                    backlogPath: 'custom/backlog.md',
+                    statusPath: 'custom/status.md',
+                },
+            };
+            await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+            clearConfigCache();
+            const paths = createWuPaths({ projectRoot: tempDir });
+            expect(paths.WU('WU-1311')).toBe('custom/wu/WU-1311.yaml');
+            expect(paths.STATUS()).toBe('custom/status.md');
+            expect(paths.BACKLOG()).toBe('custom/backlog.md');
+        });
+        it('should use WU_PATHS for stamp file generation', () => {
+            const stampPath = WU_PATHS.STAMP('WU-1311');
+            expect(stampPath).toContain('WU-1311.done');
+        });
+    });
+    describe('AC2: state-doctor warns when configured paths are missing', () => {
+        it('should detect missing WU directory', async () => {
+            // Create a config pointing to non-existent paths
+            const customConfig = {
+                version: '1.0.0',
+                directories: {
+                    wuDir: 'nonexistent/wu',
+                },
+            };
+            await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+            clearConfigCache();
+            // getResolvedPaths returns paths even if they don't exist
+            // state-doctor should check existence and warn
+            const { getResolvedPaths } = await import('@lumenflow/core/dist/lumenflow-config.js');
+            const paths = getResolvedPaths({ projectRoot: tempDir });
+            expect(paths.wuDir).toBe(path.join(tempDir, 'nonexistent/wu'));
+            // The warnMissingPaths function in state-doctor.ts checks existsSync
+            // This verifies the path is properly resolved for checking
+        });
+    });
+    describe('AC3: Config overrides are respected across wu-* commands', () => {
+        it('should use custom initiatives directory from config', async () => {
+            const customConfig = {
+                version: '1.0.0',
+                directories: {
+                    initiativesDir: 'custom/initiatives',
+                },
+            };
+            await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+            clearConfigCache();
+            const paths = createWuPaths({ projectRoot: tempDir });
+            expect(paths.INITIATIVES_DIR()).toBe('custom/initiatives');
+        });
+        it('should use custom plans directory from config', async () => {
+            const customConfig = {
+                version: '1.0.0',
+                directories: {
+                    plansDir: 'custom/plans',
+                },
+            };
+            await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+            clearConfigCache();
+            const paths = createWuPaths({ projectRoot: tempDir });
+            expect(paths.PLANS_DIR()).toBe('custom/plans');
+        });
+        it('should use custom templates directory from config', async () => {
+            const customConfig = {
+                version: '1.0.0',
+                directories: {
+                    templatesDir: 'custom/templates',
+                },
+            };
+            await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+            clearConfigCache();
+            const paths = createWuPaths({ projectRoot: tempDir });
+            expect(paths.TEMPLATES_DIR()).toBe('custom/templates');
+        });
+        it('should use custom onboarding directory from config', async () => {
+            const customConfig = {
+                version: '1.0.0',
+                directories: {
+                    onboardingDir: 'custom/onboarding',
+                },
+            };
+            await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+            clearConfigCache();
+            const paths = createWuPaths({ projectRoot: tempDir });
+            expect(paths.ONBOARDING_DIR()).toBe('custom/onboarding');
+        });
+    });
+    describe('AC4: Whitelist paths use config-based values', () => {
+        it('should generate correct whitelist paths for wu:done staged file validation', async () => {
+            const customConfig = {
+                version: '1.0.0',
+                directories: {
+                    wuDir: 'tasks/wu',
+                    backlogPath: 'tasks/backlog.md',
+                    statusPath: 'tasks/status.md',
+                },
+            };
+            await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+            clearConfigCache();
+            const config = getConfig({ projectRoot: tempDir });
+            const wuId = 'WU-1311';
+            // The whitelist should use config paths, not hardcoded ones
+            const expectedWuPath = path.join(config.directories.wuDir, `${wuId}.yaml`);
+            const expectedBacklogPath = config.directories.backlogPath;
+            const expectedStatusPath = config.directories.statusPath;
+            expect(expectedWuPath).toBe('tasks/wu/WU-1311.yaml');
+            expect(expectedBacklogPath).toBe('tasks/backlog.md');
+            expect(expectedStatusPath).toBe('tasks/status.md');
+        });
+    });
+    describe('AC5: Error messages use config-based paths', () => {
+        it('should provide config-aware error messages for missing WU', async () => {
+            const customConfig = {
+                version: '1.0.0',
+                directories: {
+                    wuDir: 'custom/wu',
+                },
+            };
+            await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+            clearConfigCache();
+            const config = getConfig({ projectRoot: tempDir });
+            // Error messages should reference the configured path, not hardcoded
+            const expectedDir = config.directories.wuDir;
+            expect(expectedDir).toBe('custom/wu');
+            // CLI commands should use this in error messages like:
+            // "WU not found in ${config.directories.wuDir}/"
+        });
+    });
+});
+describe('WU-1311: validateStagedFiles whitelist paths', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(path.join(tmpdir(), 'whitelist-test-'));
+        clearConfigCache();
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+        clearConfigCache();
+    });
+    it('should generate whitelist paths from config', async () => {
+        const customConfig = {
+            version: '1.0.0',
+            directories: {
+                wuDir: 'my/tasks/wu',
+                backlogPath: 'my/tasks/backlog.md',
+                statusPath: 'my/tasks/status.md',
+            },
+        };
+        await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+        clearConfigCache();
+        const config = getConfig({ projectRoot: tempDir });
+        // Helper function that CLI should use to generate whitelist
+        const generateWhitelist = (id) => [
+            path.join(config.directories.wuDir, `${id}.yaml`),
+            config.directories.statusPath,
+            config.directories.backlogPath,
+        ];
+        const whitelist = generateWhitelist('WU-1311');
+        expect(whitelist).toContain('my/tasks/wu/WU-1311.yaml');
+        expect(whitelist).toContain('my/tasks/backlog.md');
+        expect(whitelist).toContain('my/tasks/status.md');
+    });
+});
+describe('WU-1311: getWorktreeCommitFiles config paths', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(path.join(tmpdir(), 'commit-files-test-'));
+        clearConfigCache();
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+        clearConfigCache();
+    });
+    it('should use config-based WU path in commit file list', async () => {
+        const customConfig = {
+            version: '1.0.0',
+            directories: {
+                wuDir: 'custom/wu',
+            },
+        };
+        await writeFile(path.join(tempDir, CONFIG_FILE), yaml.stringify(customConfig), 'utf-8');
+        clearConfigCache();
+        const config = getConfig({ projectRoot: tempDir });
+        // The getWorktreeCommitFiles function should use config paths
+        const wuId = 'WU-1311';
+        const expectedWuPath = path.join(config.directories.wuDir, `${wuId}.yaml`);
+        expect(expectedWuPath).toBe('custom/wu/WU-1311.yaml');
+    });
+});

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

@@ -0,0 +1,126 @@
+/**
+ * Tests for plan:create command (WU-1313)
+ *
+ * The plan:create command creates plan files in the repo-native plansDir.
+ * Plans can be linked to WUs (via spec_refs) or initiatives (via related_plan).
+ *
+ * TDD: These tests are written BEFORE the implementation.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+// Mock modules before importing
+vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
+    getGitForCwd: vi.fn(() => ({
+        branch: vi.fn().mockResolvedValue({ current: 'main' }),
+        status: vi.fn().mockResolvedValue({ isClean: () => true }),
+    })),
+}));
+vi.mock('@lumenflow/core/dist/wu-helpers.js', () => ({
+    ensureOnMain: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
+    withMicroWorktree: vi.fn(async ({ execute }) => {
+        const tempDir = join(tmpdir(), `plan-create-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        return execute({ worktreePath: tempDir });
+    }),
+}));
+describe('plan:create command', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `plan-create-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        vi.clearAllMocks();
+    });
+    describe('createPlan', () => {
+        it('should create a plan file in repo plansDir', async () => {
+            const { createPlan } = await import('../plan-create.js');
+            const plansDir = join(tempDir, 'docs', '04-operations', 'plans');
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = createPlan(tempDir, 'WU-1313', 'Implement plan tooling');
+            expect(existsSync(planPath)).toBe(true);
+            const content = readFileSync(planPath, 'utf-8');
+            expect(content).toContain('# WU-1313');
+            expect(content).toContain('Implement plan tooling');
+            expect(content).toContain('## Goal');
+            expect(content).toContain('## Scope');
+            expect(content).toContain('## Approach');
+        });
+        it('should create plans directory if it does not exist', async () => {
+            const { createPlan } = await import('../plan-create.js');
+            // Do NOT pre-create the plans directory
+            const planPath = createPlan(tempDir, 'WU-1313', 'Test Plan');
+            expect(existsSync(planPath)).toBe(true);
+            expect(planPath).toContain('docs/04-operations/plans');
+        });
+        it('should not overwrite existing plan file', async () => {
+            const { createPlan } = await import('../plan-create.js');
+            const plansDir = join(tempDir, 'docs', '04-operations', 'plans');
+            mkdirSync(plansDir, { recursive: true });
+            // Create existing file
+            const existingPath = join(plansDir, 'WU-1313-plan.md');
+            writeFileSync(existingPath, '# Existing Content');
+            expect(() => createPlan(tempDir, 'WU-1313', 'New Title')).toThrow();
+        });
+        it('should support initiative ID format', async () => {
+            const { createPlan } = await import('../plan-create.js');
+            const planPath = createPlan(tempDir, 'INIT-001', 'Initiative Plan');
+            expect(existsSync(planPath)).toBe(true);
+            const content = readFileSync(planPath, 'utf-8');
+            expect(content).toContain('# INIT-001');
+            expect(content).toContain('Initiative Plan');
+        });
+    });
+    describe('getPlanUri', () => {
+        it('should return lumenflow:// URI for plan', async () => {
+            const { getPlanUri } = await import('../plan-create.js');
+            expect(getPlanUri('WU-1313')).toBe('lumenflow://plans/WU-1313-plan.md');
+            expect(getPlanUri('INIT-001')).toBe('lumenflow://plans/INIT-001-plan.md');
+        });
+    });
+    describe('validatePlanId', () => {
+        it('should accept valid WU and INIT IDs', async () => {
+            const { validatePlanId } = await import('../plan-create.js');
+            expect(() => validatePlanId('WU-1313')).not.toThrow();
+            expect(() => validatePlanId('INIT-001')).not.toThrow();
+            expect(() => validatePlanId('INIT-TOOLING')).not.toThrow();
+        });
+        it('should reject invalid IDs', async () => {
+            const { validatePlanId } = await import('../plan-create.js');
+            expect(() => validatePlanId('invalid')).toThrow();
+            expect(() => validatePlanId('')).toThrow();
+            expect(() => validatePlanId('WU1313')).toThrow();
+        });
+    });
+    describe('getCommitMessage', () => {
+        it('should generate correct commit message', async () => {
+            const { getCommitMessage } = await import('../plan-create.js');
+            expect(getCommitMessage('WU-1313', 'Feature Plan')).toBe('docs: create plan for wu-1313 - Feature Plan');
+            expect(getCommitMessage('INIT-001', 'Auth System')).toBe('docs: create plan for init-001 - Auth System');
+        });
+    });
+});
+describe('plan:create CLI exports', () => {
+    it('should export main function for CLI entry', async () => {
+        const planCreate = await import('../plan-create.js');
+        expect(typeof planCreate.main).toBe('function');
+    });
+    it('should export all required functions', async () => {
+        const planCreate = await import('../plan-create.js');
+        expect(typeof planCreate.createPlan).toBe('function');
+        expect(typeof planCreate.getPlanUri).toBe('function');
+        expect(typeof planCreate.validatePlanId).toBe('function');
+        expect(typeof planCreate.getCommitMessage).toBe('function');
+        expect(typeof planCreate.LOG_PREFIX).toBe('string');
+    });
+});

package/dist/__tests__/plan-edit.test.js

@@ -0,0 +1,157 @@
+/**
+ * Tests for plan:edit command (WU-1313)
+ *
+ * The plan:edit command edits existing plan files in the repo-native plansDir.
+ * Uses micro-worktree isolation for atomic commits.
+ *
+ * TDD: These tests are written BEFORE the implementation.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+/** Test constants - avoid sonarjs/no-duplicate-string */
+const TEST_PLANS_DIR = 'docs/04-operations/plans';
+const TEST_WU_ID = 'WU-1313';
+// Mock modules before importing
+vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
+    getGitForCwd: vi.fn(() => ({
+        branch: vi.fn().mockResolvedValue({ current: 'main' }),
+        status: vi.fn().mockResolvedValue({ isClean: () => true }),
+    })),
+}));
+vi.mock('@lumenflow/core/dist/wu-helpers.js', () => ({
+    ensureOnMain: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
+    withMicroWorktree: vi.fn(async ({ execute }) => {
+        const tempDir = join(tmpdir(), `plan-edit-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        return execute({ worktreePath: tempDir });
+    }),
+}));
+describe('plan:edit command', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `plan-edit-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        vi.clearAllMocks();
+    });
+    describe('updatePlanSection', () => {
+        it('should update a section in the plan', async () => {
+            const { updatePlanSection } = await import('../plan-edit.js');
+            // Setup plan file
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, `# WU-1313 Plan
+
+## Goal
+
+Original goal content.
+
+## Scope
+
+In scope items.
+`);
+            // Update goal section
+            const changed = updatePlanSection(planPath, 'Goal', 'New goal content from edit.');
+            expect(changed).toBe(true);
+            const content = readFileSync(planPath, 'utf-8');
+            expect(content).toContain('New goal content from edit.');
+            expect(content).not.toContain('Original goal content.');
+            expect(content).toContain('In scope items.'); // Other sections unchanged
+        });
+        it('should return false if section not found', async () => {
+            const { updatePlanSection } = await import('../plan-edit.js');
+            // Setup plan file without the target section
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, `# WU-1313 Plan
+
+## Goal
+
+Goal content.
+`);
+            // Try to update non-existent section
+            const changed = updatePlanSection(planPath, 'NonExistent', 'New content');
+            expect(changed).toBe(false);
+        });
+        it('should throw if plan file not found', async () => {
+            const { updatePlanSection } = await import('../plan-edit.js');
+            const planPath = join(tempDir, 'nonexistent.md');
+            expect(() => updatePlanSection(planPath, 'Goal', 'content')).toThrow();
+        });
+    });
+    describe('appendToSection', () => {
+        it('should append content to an existing section', async () => {
+            const { appendToSection } = await import('../plan-edit.js');
+            // Setup plan file
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, `# WU-1313 Plan
+
+## Risks
+
+- Risk 1
+
+## References
+`);
+            // Append to risks section
+            const changed = appendToSection(planPath, 'Risks', '- Risk 2 from append');
+            expect(changed).toBe(true);
+            const content = readFileSync(planPath, 'utf-8');
+            expect(content).toContain('- Risk 1');
+            expect(content).toContain('- Risk 2 from append');
+        });
+    });
+    describe('getPlanPath', () => {
+        it('should resolve plan path from ID', async () => {
+            const { getPlanPath } = await import('../plan-edit.js');
+            // Setup plan file
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, '# Plan');
+            process.chdir(tempDir);
+            const resolved = getPlanPath('WU-1313');
+            expect(resolved).toContain(`${TEST_WU_ID}-plan.md`);
+        });
+        it('should throw if plan not found', async () => {
+            const { getPlanPath } = await import('../plan-edit.js');
+            process.chdir(tempDir);
+            expect(() => getPlanPath('WU-9999')).toThrow();
+        });
+    });
+    describe('getCommitMessage', () => {
+        it('should generate correct commit message', async () => {
+            const { getCommitMessage } = await import('../plan-edit.js');
+            expect(getCommitMessage('WU-1313', 'Goal')).toBe('docs: update Goal section in wu-1313 plan');
+            expect(getCommitMessage('INIT-001', 'Scope')).toBe('docs: update Scope section in init-001 plan');
+        });
+    });
+});
+describe('plan:edit CLI exports', () => {
+    it('should export main function for CLI entry', async () => {
+        const planEdit = await import('../plan-edit.js');
+        expect(typeof planEdit.main).toBe('function');
+    });
+    it('should export all required functions', async () => {
+        const planEdit = await import('../plan-edit.js');
+        expect(typeof planEdit.updatePlanSection).toBe('function');
+        expect(typeof planEdit.appendToSection).toBe('function');
+        expect(typeof planEdit.getPlanPath).toBe('function');
+        expect(typeof planEdit.getCommitMessage).toBe('function');
+        expect(typeof planEdit.LOG_PREFIX).toBe('string');
+    });
+});