@lumenflow/cli 2.4.0 → 2.5.0

package/dist/__tests__/onboarding-smoke-test.test.js

@@ -0,0 +1,211 @@
+/**
+ * @file onboarding-smoke-test.test.ts
+ * Tests for onboarding smoke-test gate (WU-1315)
+ *
+ * This gate verifies the lumenflow init + wu:create flows work correctly
+ * by running them in an isolated temp directory.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+// Import the smoke-test module
+import { runOnboardingSmokeTest, validateInitScripts, validateLaneInferenceFormat, } from '../onboarding-smoke-test.js';
+/** Constants for test files to avoid duplicate string literals */
+const PACKAGE_JSON_FILE = 'package.json';
+const LANE_INFERENCE_FILE = '.lumenflow.lane-inference.yaml';
+const TEST_PROJECT_NAME = 'test-project';
+describe('onboarding smoke-test gate (WU-1315)', () => {
+    let tempDir;
+    beforeEach(() => {
+        // Create a temporary directory for each test
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-smoke-test-'));
+    });
+    afterEach(() => {
+        // Clean up temporary directory
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('runOnboardingSmokeTest', () => {
+        it('should return success when all validations pass', async () => {
+            // This is an integration test - it runs the full smoke test
+            const result = await runOnboardingSmokeTest({ tempDir });
+            expect(result.success).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should clean up temp directory after test', async () => {
+            // Run with a specific temp dir
+            const testTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-smoke-cleanup-'));
+            await runOnboardingSmokeTest({ tempDir: testTempDir, cleanup: true });
+            // Temp dir should be cleaned up
+            expect(fs.existsSync(testTempDir)).toBe(false);
+        });
+        it('should preserve temp directory when cleanup is false', async () => {
+            const testTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-smoke-preserve-'));
+            try {
+                await runOnboardingSmokeTest({ tempDir: testTempDir, cleanup: false });
+                // Temp dir should still exist
+                expect(fs.existsSync(testTempDir)).toBe(true);
+            }
+            finally {
+                // Manual cleanup
+                if (fs.existsSync(testTempDir)) {
+                    fs.rmSync(testTempDir, { recursive: true, force: true });
+                }
+            }
+        });
+        it('should report errors when validation fails', async () => {
+            // Create a directory without proper package.json scripts (init doesn't create them by default without --full)
+            const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-smoke-invalid-'));
+            try {
+                // Create an empty package.json (missing required scripts)
+                fs.writeFileSync(path.join(testDir, PACKAGE_JSON_FILE), JSON.stringify({ name: 'test', scripts: {} }, null, 2));
+                // Run smoke test - should skip scaffolding and validate existing state
+                const result = validateInitScripts({ projectDir: testDir });
+                expect(result.valid).toBe(false);
+                expect(result.missingScripts.length).toBeGreaterThan(0);
+            }
+            finally {
+                if (fs.existsSync(testDir)) {
+                    fs.rmSync(testDir, { recursive: true, force: true });
+                }
+            }
+        });
+    });
+    describe('validateInitScripts', () => {
+        it('should pass when all required scripts are present', () => {
+            // Create package.json with required scripts
+            const packageJson = {
+                name: TEST_PROJECT_NAME,
+                scripts: {
+                    'wu:claim': 'wu-claim',
+                    'wu:done': 'wu-done',
+                    'wu:create': 'wu-create',
+                    gates: 'gates',
+                },
+            };
+            fs.writeFileSync(path.join(tempDir, PACKAGE_JSON_FILE), JSON.stringify(packageJson, null, 2));
+            const result = validateInitScripts({ projectDir: tempDir });
+            expect(result.valid).toBe(true);
+            expect(result.missingScripts).toHaveLength(0);
+        });
+        it('should fail when required scripts are missing', () => {
+            // Create package.json without LumenFlow scripts
+            const packageJson = {
+                name: TEST_PROJECT_NAME,
+                scripts: {
+                    test: 'vitest',
+                },
+            };
+            fs.writeFileSync(path.join(tempDir, PACKAGE_JSON_FILE), JSON.stringify(packageJson, null, 2));
+            const result = validateInitScripts({ projectDir: tempDir });
+            expect(result.valid).toBe(false);
+            expect(result.missingScripts).toContain('wu:claim');
+            expect(result.missingScripts).toContain('wu:done');
+            expect(result.missingScripts).toContain('gates');
+        });
+        it('should fail when package.json does not exist', () => {
+            const result = validateInitScripts({ projectDir: tempDir });
+            expect(result.valid).toBe(false);
+            expect(result.error).toContain('package.json');
+        });
+        it('should verify scripts use standalone binary format', () => {
+            // Scripts should be 'wu-claim' not 'pnpm exec lumenflow wu:claim'
+            const packageJson = {
+                name: TEST_PROJECT_NAME,
+                scripts: {
+                    'wu:claim': 'pnpm exec lumenflow wu:claim', // Wrong format
+                    'wu:done': 'wu-done',
+                    'wu:create': 'wu-create',
+                    gates: 'gates',
+                },
+            };
+            fs.writeFileSync(path.join(tempDir, PACKAGE_JSON_FILE), JSON.stringify(packageJson, null, 2));
+            const result = validateInitScripts({ projectDir: tempDir });
+            expect(result.valid).toBe(false);
+            expect(result.invalidScripts).toContain('wu:claim');
+        });
+    });
+    describe('validateLaneInferenceFormat', () => {
+        it('should pass when lane-inference.yaml has correct hierarchical format', () => {
+            // Create lane-inference.yaml with correct format
+            const laneInference = `# Lane Inference Configuration
+Framework:
+  Core:
+    description: 'Core library'
+    code_paths:
+      - 'packages/core/**'
+    keywords:
+      - 'core'
+
+Content:
+  Documentation:
+    description: 'Documentation'
+    code_paths:
+      - 'docs/**'
+    keywords:
+      - 'docs'
+`;
+            fs.writeFileSync(path.join(tempDir, LANE_INFERENCE_FILE), laneInference);
+            const result = validateLaneInferenceFormat({ projectDir: tempDir });
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should fail when lane-inference.yaml uses flat lanes array', () => {
+            // Create lane-inference.yaml with old flat format
+            const laneInference = `# Lane Inference Configuration
+lanes:
+  - name: Framework
+    code_paths:
+      - 'packages/**'
+`;
+            fs.writeFileSync(path.join(tempDir, LANE_INFERENCE_FILE), laneInference);
+            const result = validateLaneInferenceFormat({ projectDir: tempDir });
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes('lanes'))).toBe(true);
+        });
+        it('should fail when lane-inference.yaml does not exist', () => {
+            const result = validateLaneInferenceFormat({ projectDir: tempDir });
+            expect(result.valid).toBe(false);
+            expect(result.error).toContain('.lumenflow.lane-inference.yaml');
+        });
+        it('should validate parent lane names are capitalized', () => {
+            const laneInference = `# Lane Inference Configuration
+framework:  # Should be 'Framework'
+  core:
+    description: 'Core library'
+    code_paths:
+      - 'packages/core/**'
+`;
+            fs.writeFileSync(path.join(tempDir, LANE_INFERENCE_FILE), laneInference);
+            const result = validateLaneInferenceFormat({ projectDir: tempDir });
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes('capitalized'))).toBe(true);
+        });
+        it('should validate sub-lanes have required fields', () => {
+            const laneInference = `# Lane Inference Configuration
+Framework:
+  Core:
+    # Missing description and code_paths
+    keywords:
+      - 'core'
+`;
+            fs.writeFileSync(path.join(tempDir, LANE_INFERENCE_FILE), laneInference);
+            const result = validateLaneInferenceFormat({ projectDir: tempDir });
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes('description') || e.includes('code_paths'))).toBe(true);
+        });
+    });
+    describe('wu:create with requireRemote=false', () => {
+        it('should run smoke test with requireRemote=false config', async () => {
+            const result = await runOnboardingSmokeTest({
+                tempDir,
+                skipWuCreate: false,
+            });
+            // The test should have validated wu:create works without a remote
+            expect(result.wuCreateValidation).toBeDefined();
+            expect(result.wuCreateValidation?.success).toBe(true);
+        });
+    });
+});

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');
+    });
+});