@lumenflow/cli 2.20.1 → 2.21.1

package/dist/__tests__/init.test.js

@@ -1,968 +0,0 @@
-/**
- * @file init.test.ts
- * Tests for lumenflow init command (WU-1171)
- *
- * Tests the new --merge mode, --client flag, AGENTS.md creation,
- * and updated vendor overlay paths.
- */
-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 { scaffoldProject } from '../init.js';
-// Constants to avoid sonarjs/no-duplicate-string
-const LUMENFLOW_MD = 'LUMENFLOW.md';
-const VENDOR_RULES_FILE = 'lumenflow.md';
-// WU-1300: Additional constants for lint compliance
-const ONBOARDING_DOCS_PATH = 'docs/04-operations/_frameworks/lumenflow/agent/onboarding';
-const DOCS_OPS_DIR = 'docs/04-operations';
-const PACKAGE_JSON_FILE = 'package.json';
-describe('lumenflow init', () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-init-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-    describe('AGENTS.md creation', () => {
-        it('should create AGENTS.md by default', async () => {
-            const options = {
-                force: false,
-                full: false,
-            };
-            await scaffoldProject(tempDir, options);
-            const agentsPath = path.join(tempDir, 'AGENTS.md');
-            expect(fs.existsSync(agentsPath)).toBe(true);
-            const content = fs.readFileSync(agentsPath, 'utf-8');
-            expect(content).toContain(LUMENFLOW_MD);
-            expect(content).toContain('universal');
-        });
-        it('should link AGENTS.md to LUMENFLOW.md', async () => {
-            const options = {
-                force: false,
-                full: false,
-            };
-            await scaffoldProject(tempDir, options);
-            const agentsContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            expect(agentsContent).toContain(`[${LUMENFLOW_MD}]`);
-        });
-    });
-    describe('--client flag', () => {
-        it('should accept --client claude', async () => {
-            const options = {
-                force: false,
-                full: false,
-                client: 'claude',
-            };
-            const result = await scaffoldProject(tempDir, options);
-            expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
-            expect(result.created).toContain('CLAUDE.md');
-        });
-        it('should accept --client cursor', async () => {
-            const options = {
-                force: false,
-                full: false,
-                client: 'cursor',
-            };
-            await scaffoldProject(tempDir, options);
-            // Cursor uses .cursor/rules/lumenflow.md (not .cursor/rules.md)
-            expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', VENDOR_RULES_FILE))).toBe(true);
-        });
-        it('should accept --client windsurf', async () => {
-            const options = {
-                force: false,
-                full: false,
-                client: 'windsurf',
-            };
-            await scaffoldProject(tempDir, options);
-            // Windsurf uses .windsurf/rules/lumenflow.md (not .windsurfrules)
-            expect(fs.existsSync(path.join(tempDir, '.windsurf', 'rules', VENDOR_RULES_FILE))).toBe(true);
-        });
-        it('should accept --client codex', async () => {
-            const options = {
-                force: false,
-                full: false,
-                client: 'codex',
-            };
-            await scaffoldProject(tempDir, options);
-            // Codex reads AGENTS.md directly, minimal extra config
-            expect(fs.existsSync(path.join(tempDir, 'AGENTS.md'))).toBe(true);
-        });
-        it('should accept --client all', async () => {
-            const options = {
-                force: false,
-                full: false,
-                client: 'all',
-            };
-            await scaffoldProject(tempDir, options);
-            // Should create all vendor files
-            expect(fs.existsSync(path.join(tempDir, 'AGENTS.md'))).toBe(true);
-            expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
-            expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', VENDOR_RULES_FILE))).toBe(true);
-            expect(fs.existsSync(path.join(tempDir, '.windsurf', 'rules', VENDOR_RULES_FILE))).toBe(true);
-        });
-        it('should treat --vendor as alias for --client (backwards compatibility)', async () => {
-            const options = {
-                force: false,
-                full: false,
-                vendor: 'claude', // Using old --vendor flag
-            };
-            await scaffoldProject(tempDir, options);
-            expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
-        });
-    });
-    describe('--merge mode', () => {
-        it('should insert LUMENFLOW block into existing file', async () => {
-            // Create existing AGENTS.md
-            const existingContent = '# My Project Agents\n\nCustom content here.\n';
-            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), existingContent);
-            const options = {
-                force: false,
-                full: false,
-                merge: true,
-            };
-            await scaffoldProject(tempDir, options);
-            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            // Should preserve original content
-            expect(content).toContain('# My Project Agents');
-            expect(content).toContain('Custom content here.');
-            // Should add LumenFlow block
-            expect(content).toContain('<!-- LUMENFLOW:START -->');
-            expect(content).toContain('<!-- LUMENFLOW:END -->');
-            expect(content).toContain(LUMENFLOW_MD);
-        });
-        it('should be idempotent (running twice produces no diff)', async () => {
-            // Create existing file
-            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), '# My Project\n');
-            const options = {
-                force: false,
-                full: false,
-                merge: true,
-            };
-            // First run
-            await scaffoldProject(tempDir, options);
-            const firstContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            // Second run
-            await scaffoldProject(tempDir, options);
-            const secondContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            expect(firstContent).toBe(secondContent);
-        });
-        it('should preserve CRLF line endings', async () => {
-            // Create existing file with CRLF
-            const existingContent = '# My Project\r\n\r\nWindows style.\r\n';
-            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), existingContent);
-            const options = {
-                force: false,
-                full: false,
-                merge: true,
-            };
-            await scaffoldProject(tempDir, options);
-            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            // Should preserve CRLF
-            expect(content).toContain('\r\n');
-            // Should not have mixed line endings (standalone LF without preceding CR)
-            const lfCount = (content.match(/(?<!\r)\n/g) || []).length;
-            expect(lfCount).toBe(0);
-        });
-        it('should warn on malformed markers and append fresh block', async () => {
-            // Create file with only START marker (malformed)
-            const malformedContent = '# My Project\n\n<!-- LUMENFLOW:START -->\nOrphan block\n';
-            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), malformedContent);
-            const options = {
-                force: false,
-                full: false,
-                merge: true,
-            };
-            const result = await scaffoldProject(tempDir, options);
-            // Should have warnings about malformed markers
-            expect(result.warnings).toBeDefined();
-            expect(result.warnings?.some((w) => w.includes('malformed'))).toBe(true);
-            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            // Should have complete block
-            expect(content).toContain('<!-- LUMENFLOW:END -->');
-        });
-    });
-    describe('createFile mode option', () => {
-        it('should skip existing files in skip mode (default)', async () => {
-            const existingContent = 'Original content';
-            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), existingContent);
-            const options = {
-                force: false,
-                full: false,
-                // Default mode is 'skip'
-            };
-            const result = await scaffoldProject(tempDir, options);
-            expect(result.skipped).toContain('AGENTS.md');
-            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            expect(content).toBe(existingContent);
-        });
-        it('should overwrite in force mode', async () => {
-            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), 'Original');
-            const options = {
-                force: true,
-                full: false,
-            };
-            const result = await scaffoldProject(tempDir, options);
-            expect(result.created).toContain('AGENTS.md');
-            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            expect(content).not.toBe('Original');
-        });
-        it('should merge in merge mode', async () => {
-            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), '# Custom Header\n');
-            const options = {
-                force: false,
-                full: false,
-                merge: true,
-            };
-            const result = await scaffoldProject(tempDir, options);
-            expect(result.merged).toContain('AGENTS.md');
-            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            expect(content).toContain('# Custom Header');
-            expect(content).toContain('<!-- LUMENFLOW:START -->');
-        });
-    });
-    describe('vendor overlay paths', () => {
-        it('should use .cursor/rules/lumenflow.md for Cursor', async () => {
-            const options = {
-                force: false,
-                full: false,
-                client: 'cursor',
-            };
-            await scaffoldProject(tempDir, options);
-            // Should NOT create old path
-            expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules.md'))).toBe(false);
-            // Should create new path
-            expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', VENDOR_RULES_FILE))).toBe(true);
-        });
-        it('should use .windsurf/rules/lumenflow.md for Windsurf', async () => {
-            const options = {
-                force: false,
-                full: false,
-                client: 'windsurf',
-            };
-            await scaffoldProject(tempDir, options);
-            // Should NOT create old path
-            expect(fs.existsSync(path.join(tempDir, '.windsurfrules'))).toBe(false);
-            // Should create new path
-            expect(fs.existsSync(path.join(tempDir, '.windsurf', 'rules', VENDOR_RULES_FILE))).toBe(true);
-        });
-    });
-    describe('CLAUDE.md location', () => {
-        it('should create single CLAUDE.md at root only', async () => {
-            const options = {
-                force: false,
-                full: false,
-                client: 'claude',
-            };
-            await scaffoldProject(tempDir, options);
-            // Should create root CLAUDE.md
-            expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
-            // Should NOT create .claude/CLAUDE.md (no duplication)
-            expect(fs.existsSync(path.join(tempDir, '.claude', 'CLAUDE.md'))).toBe(false);
-        });
-    });
-    // WU-1286: --full is now the default
-    describe('--full default and --minimal flag', () => {
-        it('should scaffold agent onboarding docs by default (full=true)', async () => {
-            const options = {
-                force: false,
-                full: true, // This is now the default when parsed
-                docsStructure: 'arc42', // WU-1309: Explicitly request arc42 for legacy test
-            };
-            await scaffoldProject(tempDir, options);
-            // Should create agent onboarding docs
-            const onboardingDir = path.join(tempDir, ONBOARDING_DOCS_PATH);
-            expect(fs.existsSync(path.join(onboardingDir, 'quick-ref-commands.md'))).toBe(true);
-            expect(fs.existsSync(path.join(onboardingDir, 'first-wu-mistakes.md'))).toBe(true);
-            expect(fs.existsSync(path.join(onboardingDir, 'troubleshooting-wu-done.md'))).toBe(true);
-        });
-        it('should skip agent onboarding docs when full=false (minimal mode)', async () => {
-            const options = {
-                force: false,
-                full: false, // Explicitly minimal
-            };
-            await scaffoldProject(tempDir, options);
-            // Should NOT create agent onboarding docs
-            const onboardingDir = path.join(tempDir, ONBOARDING_DOCS_PATH);
-            expect(fs.existsSync(path.join(onboardingDir, 'quick-ref-commands.md'))).toBe(false);
-        });
-        it('should still create core files in minimal mode', async () => {
-            const options = {
-                force: false,
-                full: false,
-            };
-            await scaffoldProject(tempDir, options);
-            // Core files should always be created
-            expect(fs.existsSync(path.join(tempDir, 'AGENTS.md'))).toBe(true);
-            expect(fs.existsSync(path.join(tempDir, LUMENFLOW_MD))).toBe(true);
-            expect(fs.existsSync(path.join(tempDir, '.lumenflow.config.yaml'))).toBe(true);
-            expect(fs.existsSync(path.join(tempDir, '.lumenflow', 'constraints.md'))).toBe(true);
-        });
-    });
-    // WU-1300: Scaffolding fixes and template portability
-    describe('WU-1300: scaffolding fixes', () => {
-        describe('lane-inference.yaml generation', () => {
-            it('should scaffold .lumenflow.lane-inference.yaml with --full', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const laneInferencePath = path.join(tempDir, '.lumenflow.lane-inference.yaml');
-                expect(fs.existsSync(laneInferencePath)).toBe(true);
-                const content = fs.readFileSync(laneInferencePath, 'utf-8');
-                // WU-1307: Should have hierarchical lane definitions (not flat lanes: array)
-                expect(content).toContain('Framework:');
-                expect(content).toContain('Content:');
-                expect(content).toContain('Operations:');
-            });
-            it('should scaffold lane-inference with framework-specific lanes when --framework is provided', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                    framework: 'Next.js',
-                };
-                await scaffoldProject(tempDir, options);
-                const laneInferencePath = path.join(tempDir, '.lumenflow.lane-inference.yaml');
-                expect(fs.existsSync(laneInferencePath)).toBe(true);
-            });
-        });
-        describe('starting-prompt.md scaffolding', () => {
-            it('should scaffold starting-prompt.md in onboarding docs with --full', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                    docsStructure: 'arc42', // WU-1309: Explicitly request arc42 for legacy test
-                };
-                await scaffoldProject(tempDir, options);
-                const onboardingDir = path.join(tempDir, ONBOARDING_DOCS_PATH);
-                const startingPromptPath = path.join(onboardingDir, 'starting-prompt.md');
-                expect(fs.existsSync(startingPromptPath)).toBe(true);
-                const content = fs.readFileSync(startingPromptPath, 'utf-8');
-                expect(content).toContain(LUMENFLOW_MD);
-                expect(content).toContain('constraints');
-            });
-        });
-        describe('template path portability', () => {
-            it('should not have absolute paths in generated templates', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                // Check common files for absolute paths
-                const filesToCheck = ['AGENTS.md', LUMENFLOW_MD, '.lumenflow/constraints.md'];
-                for (const file of filesToCheck) {
-                    const filePath = path.join(tempDir, file);
-                    if (fs.existsSync(filePath)) {
-                        const content = fs.readFileSync(filePath, 'utf-8');
-                        // Should not contain absolute paths (unix home dirs or macOS user dirs)
-                        // Build patterns dynamically to avoid triggering pre-commit hook
-                        const homePattern = new RegExp('/' + 'home' + '/' + '\\w+');
-                        const usersPattern = new RegExp('/' + 'Users' + '/' + '\\w+');
-                        expect(content).not.toMatch(homePattern);
-                        expect(content).not.toMatch(usersPattern);
-                        // Should use <project-root> placeholder for project root references
-                        // or relative paths like ./docs/
-                    }
-                }
-            });
-            it('should use <project-root> placeholder in templates where project root is needed', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const agentsContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-                // AGENTS.md should have placeholder for cd command back to project root
-                // Using {{PROJECT_ROOT}} token which gets replaced with actual path
-                expect(agentsContent).toMatch(/cd\s+[\w./\\${}]+/); // Should have cd command with path
-            });
-        });
-        describe('AGENTS.md quick-ref link', () => {
-            it('should have correct quick-ref-commands.md link in AGENTS.md when --full', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                    docsStructure: 'arc42', // WU-1309: Explicitly request arc42 for legacy test
-                };
-                await scaffoldProject(tempDir, options);
-                const agentsContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-                // If quick-ref is mentioned, link should point to correct location
-                // docs/04-operations/_frameworks/lumenflow/agent/onboarding/quick-ref-commands.md
-                if (agentsContent.includes('quick-ref')) {
-                    expect(agentsContent).toContain(`${ONBOARDING_DOCS_PATH}/quick-ref-commands.md`);
-                }
-            });
-        });
-        describe('--docs-structure flag', () => {
-            it('should accept --docs-structure simple', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                    docsStructure: 'simple',
-                };
-                await scaffoldProject(tempDir, options);
-                // Simple structure uses docs/ directly, not arc42 structure
-                expect(fs.existsSync(path.join(tempDir, 'docs'))).toBe(true);
-            });
-            it('should accept --docs-structure arc42', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                    docsStructure: 'arc42',
-                };
-                await scaffoldProject(tempDir, options);
-                // Arc42 uses numbered directories: 01-*, 02-*, etc.
-                // The current default is arc42-style with 04-operations
-                const operationsDir = path.join(tempDir, DOCS_OPS_DIR);
-                expect(fs.existsSync(operationsDir)).toBe(true);
-            });
-            it('should auto-detect existing docs structure', async () => {
-                // Create existing simple structure
-                fs.mkdirSync(path.join(tempDir, 'docs'), { recursive: true });
-                fs.writeFileSync(path.join(tempDir, 'docs/README.md'), '# Docs\n');
-                const options = {
-                    force: false,
-                    full: true,
-                    // No docsStructure specified - should auto-detect
-                };
-                await scaffoldProject(tempDir, options);
-                // Should preserve existing structure
-                expect(fs.existsSync(path.join(tempDir, 'docs/README.md'))).toBe(true);
-            });
-        });
-        describe('package.json scripts injection', () => {
-            it('should inject LumenFlow scripts into existing package.json', async () => {
-                // Create existing package.json
-                const existingPackageJson = {
-                    name: 'test-project',
-                    version: '1.0.0',
-                    scripts: {
-                        test: 'vitest',
-                        build: 'tsc',
-                    },
-                };
-                fs.writeFileSync(path.join(tempDir, PACKAGE_JSON_FILE), JSON.stringify(existingPackageJson, null, 2));
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const packageJson = JSON.parse(fs.readFileSync(path.join(tempDir, PACKAGE_JSON_FILE), 'utf-8'));
-                // Should preserve existing scripts
-                expect(packageJson.scripts.test).toBe('vitest');
-                expect(packageJson.scripts.build).toBe('tsc');
-                // Should add LumenFlow scripts
-                expect(packageJson.scripts['wu:claim']).toBeDefined();
-                expect(packageJson.scripts['wu:done']).toBeDefined();
-                expect(packageJson.scripts.gates).toBeDefined();
-            });
-            it('should not overwrite existing LumenFlow scripts unless --force', async () => {
-                // Create existing package.json with custom wu:claim
-                const existingPackageJson = {
-                    name: 'test-project',
-                    scripts: {
-                        'wu:claim': 'custom-claim-command',
-                    },
-                };
-                fs.writeFileSync(path.join(tempDir, PACKAGE_JSON_FILE), JSON.stringify(existingPackageJson, null, 2));
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const packageJson = JSON.parse(fs.readFileSync(path.join(tempDir, PACKAGE_JSON_FILE), 'utf-8'));
-                // Should preserve custom script
-                expect(packageJson.scripts['wu:claim']).toBe('custom-claim-command');
-            });
-            it('should create package.json with LumenFlow scripts if none exists', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const packageJsonPath = path.join(tempDir, PACKAGE_JSON_FILE);
-                if (fs.existsSync(packageJsonPath)) {
-                    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                    expect(packageJson.scripts).toBeDefined();
-                }
-            });
-        });
-    });
-    // WU-1382: Improved templates for agent clarity
-    describe('WU-1382: improved templates for agent clarity', () => {
-        describe('CLAUDE.md template enhancements', () => {
-            it('should include CLI commands table inline in CLAUDE.md', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'claude',
-                };
-                await scaffoldProject(tempDir, options);
-                const claudeMdPath = path.join(tempDir, 'CLAUDE.md');
-                expect(fs.existsSync(claudeMdPath)).toBe(true);
-                const content = fs.readFileSync(claudeMdPath, 'utf-8');
-                // Should have CLI commands table with common commands
-                expect(content).toContain('| Command');
-                expect(content).toContain('wu:claim');
-                expect(content).toContain('wu:done');
-                expect(content).toContain('wu:status');
-                expect(content).toContain('gates');
-            });
-            it('should include warning about manual YAML editing in CLAUDE.md', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'claude',
-                };
-                await scaffoldProject(tempDir, options);
-                const claudeMdPath = path.join(tempDir, 'CLAUDE.md');
-                const content = fs.readFileSync(claudeMdPath, 'utf-8');
-                // Should warn against manual WU YAML edits
-                expect(content).toMatch(/do\s+not\s+(manually\s+)?edit|never\s+(manually\s+)?edit/i);
-                expect(content).toMatch(/wu.*yaml|yaml.*wu/i);
-            });
-        });
-        describe('config.yaml managed file header', () => {
-            it('should include managed file header in .lumenflow.config.yaml', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                };
-                await scaffoldProject(tempDir, options);
-                const configPath = path.join(tempDir, '.lumenflow.config.yaml');
-                expect(fs.existsSync(configPath)).toBe(true);
-                const content = fs.readFileSync(configPath, 'utf-8');
-                // Should have managed file header
-                expect(content).toMatch(/LUMENFLOW\s+MANAGED\s+FILE/i);
-                expect(content).toMatch(/do\s+not\s+(manually\s+)?edit/i);
-            });
-        });
-        describe('lane-inference.yaml managed file header', () => {
-            it('should include managed file header in .lumenflow.lane-inference.yaml', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const laneInferencePath = path.join(tempDir, '.lumenflow.lane-inference.yaml');
-                expect(fs.existsSync(laneInferencePath)).toBe(true);
-                const content = fs.readFileSync(laneInferencePath, 'utf-8');
-                // Should have managed file header
-                expect(content).toMatch(/LUMENFLOW\s+MANAGED\s+FILE/i);
-                expect(content).toMatch(/do\s+not\s+(manually\s+)?edit/i);
-            });
-        });
-    });
-    // WU-1383: CLI safeguards against manual file editing
-    describe('WU-1383: CLI safeguards for Claude client', () => {
-        const CONFIG_FILE_NAME = '.lumenflow.config.yaml';
-        describe('enforcement hooks enabled by default for --client claude', () => {
-            it('should add enforcement hooks config when --client claude is used', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'claude',
-                };
-                await scaffoldProject(tempDir, options);
-                const configPath = path.join(tempDir, CONFIG_FILE_NAME);
-                expect(fs.existsSync(configPath)).toBe(true);
-                const content = fs.readFileSync(configPath, 'utf-8');
-                // Should have enforcement hooks enabled for claude-code
-                expect(content).toContain('claude-code');
-                expect(content).toContain('enforcement');
-                expect(content).toContain('hooks: true');
-            });
-            it('should set block_outside_worktree to true by default for claude client', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'claude',
-                };
-                await scaffoldProject(tempDir, options);
-                const configPath = path.join(tempDir, CONFIG_FILE_NAME);
-                const content = fs.readFileSync(configPath, 'utf-8');
-                expect(content).toContain('block_outside_worktree: true');
-            });
-            it('should NOT add enforcement hooks for other clients like cursor', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'cursor',
-                };
-                await scaffoldProject(tempDir, options);
-                const configPath = path.join(tempDir, CONFIG_FILE_NAME);
-                const content = fs.readFileSync(configPath, 'utf-8');
-                // Should NOT have claude-code enforcement section (check for the nested enforcement block)
-                // Note: The default config has agents.defaultClient: claude-code, but no enforcement section
-                expect(content).not.toContain('block_outside_worktree');
-                expect(content).not.toMatch(/claude-code:\s*\n\s*enforcement/);
-            });
-        });
-        describe('warning when config already exists', () => {
-            it('should add warning to result when config yaml already exists', async () => {
-                // Create existing config file
-                fs.writeFileSync(path.join(tempDir, CONFIG_FILE_NAME), '# Existing config\ndirectories:\n  tasksDir: docs/tasks\n');
-                const options = {
-                    force: false,
-                    full: false,
-                };
-                const result = await scaffoldProject(tempDir, options);
-                // Should have warning about existing config
-                expect(result.warnings).toBeDefined();
-                expect(result.warnings?.some((w) => w.includes('already exists'))).toBe(true);
-                // Warning should suggest CLI commands
-                expect(result.warnings?.some((w) => w.includes('CLI') || w.includes('lumenflow'))).toBe(true);
-            });
-            it('should skip config file when it already exists (not force)', async () => {
-                const existingContent = '# My custom config\n';
-                fs.writeFileSync(path.join(tempDir, CONFIG_FILE_NAME), existingContent);
-                const options = {
-                    force: false,
-                    full: false,
-                };
-                const result = await scaffoldProject(tempDir, options);
-                expect(result.skipped).toContain(CONFIG_FILE_NAME);
-                // Content should not be changed
-                const content = fs.readFileSync(path.join(tempDir, CONFIG_FILE_NAME), 'utf-8');
-                expect(content).toBe(existingContent);
-            });
-        });
-        describe('post-init output shows CLI commands prominently', () => {
-            // Note: These test the ScaffoldResult which contains info for the CLI output
-            // The main() function uses these to print output
-            it('should include CLI usage guidance in warnings when config exists', async () => {
-                fs.writeFileSync(path.join(tempDir, CONFIG_FILE_NAME), '# Existing\n');
-                const options = {
-                    force: false,
-                    full: false,
-                };
-                const result = await scaffoldProject(tempDir, options);
-                // Warning should mention CLI commands for editing config
-                expect(result.warnings?.some((w) => /pnpm|lumenflow|CLI/i.test(w))).toBe(true);
-            });
-        });
-        describe('warning message suggests CLI commands not manual editing', () => {
-            it('should warn users to use CLI commands instead of manual editing', async () => {
-                fs.writeFileSync(path.join(tempDir, CONFIG_FILE_NAME), '# Existing config\n');
-                const options = {
-                    force: false,
-                    full: false,
-                };
-                const result = await scaffoldProject(tempDir, options);
-                // Should have a warning that mentions not to manually edit
-                expect(result.warnings?.some((w) => w.includes('manual') || w.includes('CLI') || w.includes('lumenflow'))).toBe(true);
-            });
-        });
-    });
-    // WU-1362: Branch guard tests for init.ts
-    describe('WU-1362: branch guard for tracked file writes', () => {
-        it('should block scaffold when on main branch and targeting main checkout', async () => {
-            // This test verifies that scaffoldProject checks branch before writing
-            // Note: This test uses a temp directory (not on main), so it should pass
-            // The actual blocking only applies when targeting main checkout on main branch
-            const options = {
-                force: false,
-                full: false,
-            };
-            // Since we're in a temp dir, not on main branch, this should work
-            const result = await scaffoldProject(tempDir, options);
-            expect(result.created.length).toBeGreaterThan(0);
-        });
-        it('should allow scaffold in worktree directory', async () => {
-            // Simulate worktree-like path by creating directory structure
-            const worktreePath = path.join(tempDir, 'worktrees', 'operations-wu-999');
-            fs.mkdirSync(worktreePath, { recursive: true });
-            const options = {
-                force: false,
-                full: false,
-            };
-            // Should succeed when in worktree-like path
-            const result = await scaffoldProject(worktreePath, options);
-            expect(result.created.length).toBeGreaterThan(0);
-        });
-    });
-    // WU-1385: Include wu-sizing-guide.md in lumenflow init onboarding docs
-    describe('WU-1385: wu-sizing-guide.md scaffolding', () => {
-        describe('wu-sizing-guide.md creation with --full', () => {
-            it('should scaffold wu-sizing-guide.md in onboarding docs with --full', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                    docsStructure: 'arc42',
-                };
-                await scaffoldProject(tempDir, options);
-                const onboardingDir = path.join(tempDir, ONBOARDING_DOCS_PATH);
-                const sizingGuidePath = path.join(onboardingDir, 'wu-sizing-guide.md');
-                expect(fs.existsSync(sizingGuidePath)).toBe(true);
-            });
-            it('should include key sizing guide content', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                    docsStructure: 'arc42',
-                };
-                await scaffoldProject(tempDir, options);
-                const onboardingDir = path.join(tempDir, ONBOARDING_DOCS_PATH);
-                const sizingGuidePath = path.join(onboardingDir, 'wu-sizing-guide.md');
-                const content = fs.readFileSync(sizingGuidePath, 'utf-8');
-                // Should have key content from the sizing guide
-                expect(content).toContain('Complexity');
-                expect(content).toContain('Tool Calls');
-                expect(content).toContain('Context');
-            });
-            it('should not scaffold wu-sizing-guide.md with --minimal (full=false)', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                };
-                await scaffoldProject(tempDir, options);
-                const onboardingDir = path.join(tempDir, ONBOARDING_DOCS_PATH);
-                const sizingGuidePath = path.join(onboardingDir, 'wu-sizing-guide.md');
-                expect(fs.existsSync(sizingGuidePath)).toBe(false);
-            });
-        });
-        describe('starting-prompt.md references sizing guide', () => {
-            it('should reference wu-sizing-guide.md in starting-prompt.md', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                    docsStructure: 'arc42',
-                };
-                await scaffoldProject(tempDir, options);
-                const onboardingDir = path.join(tempDir, ONBOARDING_DOCS_PATH);
-                const startingPromptPath = path.join(onboardingDir, 'starting-prompt.md');
-                const content = fs.readFileSync(startingPromptPath, 'utf-8');
-                // Should reference the sizing guide
-                expect(content).toContain('wu-sizing-guide.md');
-            });
-        });
-    });
-    // WU-1408: safe-git and pre-commit hook scaffolding
-    describe('WU-1408: safe-git and pre-commit scaffolding', () => {
-        describe('safe-git wrapper', () => {
-            it('should scaffold scripts/safe-git', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const safeGitPath = path.join(tempDir, 'scripts', 'safe-git');
-                expect(fs.existsSync(safeGitPath)).toBe(true);
-            });
-            it('should make safe-git executable', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const safeGitPath = path.join(tempDir, 'scripts', 'safe-git');
-                const stats = fs.statSync(safeGitPath);
-                // Check for executable bit (owner, group, or other)
-                // eslint-disable-next-line no-bitwise
-                const isExecutable = (stats.mode & 0o111) !== 0;
-                expect(isExecutable).toBe(true);
-            });
-            it('should include worktree remove block in safe-git', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const safeGitPath = path.join(tempDir, 'scripts', 'safe-git');
-                const content = fs.readFileSync(safeGitPath, 'utf-8');
-                expect(content).toContain('worktree');
-                expect(content).toContain('remove');
-                expect(content).toContain('BLOCKED');
-            });
-            it('should scaffold safe-git even in minimal mode', async () => {
-                const options = {
-                    force: false,
-                    full: false, // minimal mode
-                };
-                await scaffoldProject(tempDir, options);
-                const safeGitPath = path.join(tempDir, 'scripts', 'safe-git');
-                expect(fs.existsSync(safeGitPath)).toBe(true);
-            });
-        });
-        describe('pre-commit hook', () => {
-            it('should scaffold .husky/pre-commit', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const preCommitPath = path.join(tempDir, '.husky', 'pre-commit');
-                expect(fs.existsSync(preCommitPath)).toBe(true);
-            });
-            it('should make pre-commit executable', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const preCommitPath = path.join(tempDir, '.husky', 'pre-commit');
-                const stats = fs.statSync(preCommitPath);
-                // eslint-disable-next-line no-bitwise
-                const isExecutable = (stats.mode & 0o111) !== 0;
-                expect(isExecutable).toBe(true);
-            });
-            it('should NOT run pnpm test in pre-commit hook', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const preCommitPath = path.join(tempDir, '.husky', 'pre-commit');
-                const content = fs.readFileSync(preCommitPath, 'utf-8');
-                // The pre-commit hook should NOT assume pnpm test exists
-                expect(content).not.toContain('pnpm test');
-                expect(content).not.toContain('npm test');
-            });
-            it('should block commits to main/master in pre-commit', async () => {
-                const options = {
-                    force: false,
-                    full: true,
-                };
-                await scaffoldProject(tempDir, options);
-                const preCommitPath = path.join(tempDir, '.husky', 'pre-commit');
-                const content = fs.readFileSync(preCommitPath, 'utf-8');
-                // Should protect main branch
-                expect(content).toContain('main');
-                expect(content).toContain('BLOCK');
-            });
-            it('should scaffold pre-commit even in minimal mode', async () => {
-                const options = {
-                    force: false,
-                    full: false, // minimal mode
-                };
-                await scaffoldProject(tempDir, options);
-                const preCommitPath = path.join(tempDir, '.husky', 'pre-commit');
-                expect(fs.existsSync(preCommitPath)).toBe(true);
-            });
-        });
-    });
-    // WU-1413: MCP server configuration scaffolding
-    describe('WU-1413: .mcp.json scaffolding', () => {
-        const MCP_JSON_FILE = '.mcp.json';
-        describe('.mcp.json creation with --client claude', () => {
-            it('should scaffold .mcp.json when --client claude is used', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'claude',
-                };
-                await scaffoldProject(tempDir, options);
-                const mcpJsonPath = path.join(tempDir, MCP_JSON_FILE);
-                expect(fs.existsSync(mcpJsonPath)).toBe(true);
-            });
-            it('should include lumenflow MCP server configuration', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'claude',
-                };
-                await scaffoldProject(tempDir, options);
-                const mcpJsonPath = path.join(tempDir, MCP_JSON_FILE);
-                const content = fs.readFileSync(mcpJsonPath, 'utf-8');
-                const mcpConfig = JSON.parse(content);
-                // Should have mcpServers key
-                expect(mcpConfig.mcpServers).toBeDefined();
-                // Should have lumenflow server entry
-                expect(mcpConfig.mcpServers.lumenflow).toBeDefined();
-                // Should use npx command
-                expect(mcpConfig.mcpServers.lumenflow.command).toBe('npx');
-                // Should reference @lumenflow/mcp package
-                expect(mcpConfig.mcpServers.lumenflow.args).toContain('@lumenflow/mcp');
-            });
-            it('should be valid JSON', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'claude',
-                };
-                await scaffoldProject(tempDir, options);
-                const mcpJsonPath = path.join(tempDir, MCP_JSON_FILE);
-                const content = fs.readFileSync(mcpJsonPath, 'utf-8');
-                // Should parse without error
-                expect(() => JSON.parse(content)).not.toThrow();
-            });
-        });
-        describe('.mcp.json creation with --client all', () => {
-            it('should scaffold .mcp.json when --client all is used', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'all',
-                };
-                await scaffoldProject(tempDir, options);
-                const mcpJsonPath = path.join(tempDir, MCP_JSON_FILE);
-                expect(fs.existsSync(mcpJsonPath)).toBe(true);
-            });
-        });
-        describe('.mcp.json NOT created with other clients', () => {
-            it('should NOT scaffold .mcp.json when --client none is used', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'none',
-                };
-                await scaffoldProject(tempDir, options);
-                const mcpJsonPath = path.join(tempDir, MCP_JSON_FILE);
-                expect(fs.existsSync(mcpJsonPath)).toBe(false);
-            });
-            it('should NOT scaffold .mcp.json when --client cursor is used', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'cursor',
-                };
-                await scaffoldProject(tempDir, options);
-                const mcpJsonPath = path.join(tempDir, MCP_JSON_FILE);
-                expect(fs.existsSync(mcpJsonPath)).toBe(false);
-            });
-            it('should NOT scaffold .mcp.json when no client is specified', async () => {
-                const options = {
-                    force: false,
-                    full: false,
-                };
-                await scaffoldProject(tempDir, options);
-                const mcpJsonPath = path.join(tempDir, MCP_JSON_FILE);
-                expect(fs.existsSync(mcpJsonPath)).toBe(false);
-            });
-        });
-        describe('.mcp.json file modes', () => {
-            it('should skip .mcp.json if it already exists (skip mode)', async () => {
-                // Create existing .mcp.json
-                const existingContent = '{"mcpServers":{"custom":{}}}';
-                fs.writeFileSync(path.join(tempDir, MCP_JSON_FILE), existingContent);
-                const options = {
-                    force: false,
-                    full: false,
-                    client: 'claude',
-                };
-                const result = await scaffoldProject(tempDir, options);
-                expect(result.skipped).toContain(MCP_JSON_FILE);
-                // Content should not be changed
-                const content = fs.readFileSync(path.join(tempDir, MCP_JSON_FILE), 'utf-8');
-                expect(content).toBe(existingContent);
-            });
-            it('should overwrite .mcp.json in force mode', async () => {
-                // Create existing .mcp.json
-                fs.writeFileSync(path.join(tempDir, MCP_JSON_FILE), '{"custom":true}');
-                const options = {
-                    force: true,
-                    full: false,
-                    client: 'claude',
-                };
-                const result = await scaffoldProject(tempDir, options);
-                expect(result.created).toContain(MCP_JSON_FILE);
-                const content = fs.readFileSync(path.join(tempDir, MCP_JSON_FILE), 'utf-8');
-                const mcpConfig = JSON.parse(content);
-                expect(mcpConfig.mcpServers.lumenflow).toBeDefined();
-            });
-        });
-    });
-});