@lumenflow/cli 2.7.0 → 2.9.0

package/dist/__tests__/init.test.js

@@ -491,4 +491,253 @@ describe('lumenflow init', () => {
             });
         });
     });
+    // 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');
+            });
+        });
+    });
 });