@lumenflow/cli 2.20.1 → 2.21.1

package/dist/__tests__/safe-git.test.js

@@ -1,190 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { execFileSync } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-const CLI_SAFE_GIT_PATH = path.resolve(__dirname, '../../bin/safe-git');
-const SCRIPTS_SAFE_GIT_PATH = path.resolve(__dirname, '../../../../../scripts/safe-git');
-// Constants for duplicate strings
-const SHOULD_HAVE_THROWN = 'Should have thrown an error';
-const GIT_CMD = 'git';
-const USER_EMAIL_CONFIG = 'user.email';
-const USER_NAME_CONFIG = 'user.name';
-const TEST_EMAIL = 'test@test.com';
-const TEST_USERNAME = 'Test';
-const FORCE_BYPASSES_LOG = 'force-bypasses.log';
-// Create a temporary directory for testing to avoid polluting the real .lumenflow directory
-const createTempDir = () => {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'safe-git-test-'));
-};
-describe('safe-git', () => {
-    // We mock child_process execution where possible, but for integration testing a script
-    // we often execute it directly. Since safe-git is a shell script, we executed it.
-    it('should fail when running "worktree remove" (CLI wrapper)', () => {
-        try {
-            execFileSync(CLI_SAFE_GIT_PATH, ['worktree', 'remove', 'some-path'], { stdio: 'pipe' });
-            expect.fail(SHOULD_HAVE_THROWN);
-        }
-        catch (error) {
-            const err = error;
-            expect(err.status).toBe(1);
-            expect(err.stderr.toString()).toContain("BLOCKED: Manual 'git worktree remove' is unsafe");
-        }
-    });
-    it('should fail when running "worktree remove" (scripts wrapper)', () => {
-        try {
-            execFileSync(SCRIPTS_SAFE_GIT_PATH, ['worktree', 'remove', 'some-path'], { stdio: 'pipe' });
-            expect.fail(SHOULD_HAVE_THROWN);
-        }
-        catch (error) {
-            const err = error;
-            expect(err.status).toBe(1);
-            expect(err.stderr.toString()).toContain('Manual');
-            expect(err.stderr.toString()).toContain('worktree remove');
-        }
-    });
-    it('should fail when running "reset --hard" (scripts wrapper)', () => {
-        try {
-            execFileSync(SCRIPTS_SAFE_GIT_PATH, ['reset', '--hard', 'HEAD'], { stdio: 'pipe' });
-            expect.fail(SHOULD_HAVE_THROWN);
-        }
-        catch (error) {
-            const err = error;
-            expect(err.status).toBe(1);
-            expect(err.stderr.toString()).toContain('reset --hard');
-        }
-    });
-    it('should fail when running "clean -fd" (scripts wrapper)', () => {
-        try {
-            execFileSync(SCRIPTS_SAFE_GIT_PATH, ['clean', '-fd'], { stdio: 'pipe' });
-            expect.fail(SHOULD_HAVE_THROWN);
-        }
-        catch (error) {
-            const err = error;
-            expect(err.status).toBe(1);
-            expect(err.stderr.toString()).toContain('clean -fd');
-        }
-    });
-    it('should fail when running "push --force" (scripts wrapper)', () => {
-        try {
-            execFileSync(SCRIPTS_SAFE_GIT_PATH, ['push', '--force'], { stdio: 'pipe' });
-            expect.fail(SHOULD_HAVE_THROWN);
-        }
-        catch (error) {
-            const err = error;
-            expect(err.status).toBe(1);
-            expect(err.stderr.toString()).toContain('push --force');
-        }
-    });
-    it('should pass through safe commands', () => {
-        // We verify it calls git by mocking git or checking output.
-        // Since we can't easily mock the system git in a real shell script execution without PATH manip,
-        // we'll check that it runs git --version correctly.
-        const output = execFileSync(CLI_SAFE_GIT_PATH, ['--version'], { encoding: 'utf-8' });
-        expect(output).toContain('git version');
-    });
-    describe('LUMENFLOW_FORCE bypass', () => {
-        let tempDir;
-        beforeEach(() => {
-            tempDir = createTempDir();
-        });
-        afterEach(() => {
-            // Clean up temp directory
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        });
-        it('should bypass blocked commands when LUMENFLOW_FORCE=1', () => {
-            // Using git --version as a safe test with force flag
-            // The key is that the env var should be respected and not block
-            const output = execFileSync(SCRIPTS_SAFE_GIT_PATH, ['--version'], {
-                encoding: 'utf-8',
-                env: { ...process.env, LUMENFLOW_FORCE: '1' },
-            });
-            expect(output).toContain('git version');
-        });
-        it('should log bypass to force-bypasses.log when LUMENFLOW_FORCE=1', () => {
-            // We need to test that a blocked command, when forced, writes to the audit log
-            // Since reset --hard is dangerous, we use a mock approach
-            // The script should create the audit log entry before executing
-            // Create a temporary git repo for this test
-            const testRepo = path.join(tempDir, 'test-repo');
-            fs.mkdirSync(testRepo, { recursive: true });
-            execFileSync(GIT_CMD, ['init'], { cwd: testRepo, stdio: 'pipe' });
-            execFileSync(GIT_CMD, ['config', USER_EMAIL_CONFIG, TEST_EMAIL], {
-                cwd: testRepo,
-                stdio: 'pipe',
-            });
-            execFileSync(GIT_CMD, ['config', USER_NAME_CONFIG, TEST_USERNAME], {
-                cwd: testRepo,
-                stdio: 'pipe',
-            });
-            // Create a file and commit
-            fs.writeFileSync(path.join(testRepo, 'test.txt'), 'test');
-            execFileSync(GIT_CMD, ['add', '.'], { cwd: testRepo, stdio: 'pipe' });
-            execFileSync(GIT_CMD, ['commit', '-m', 'init'], { cwd: testRepo, stdio: 'pipe' });
-            // Run safe-git with force to reset --hard (should succeed with log)
-            execFileSync(SCRIPTS_SAFE_GIT_PATH, ['reset', '--hard', 'HEAD'], {
-                cwd: testRepo,
-                encoding: 'utf-8',
-                env: { ...process.env, LUMENFLOW_FORCE: '1' },
-            });
-            // Check that the force bypass log exists and contains the entry
-            const bypassLog = path.join(testRepo, '.lumenflow', FORCE_BYPASSES_LOG);
-            expect(fs.existsSync(bypassLog)).toBe(true);
-            const logContent = fs.readFileSync(bypassLog, 'utf-8');
-            expect(logContent).toContain('reset --hard');
-            expect(logContent).toContain('BYPASSED');
-        });
-        it('should include LUMENFLOW_FORCE_REASON in audit log when provided', () => {
-            const testRepo = path.join(tempDir, 'test-repo-reason');
-            fs.mkdirSync(testRepo, { recursive: true });
-            execFileSync(GIT_CMD, ['init'], { cwd: testRepo, stdio: 'pipe' });
-            execFileSync(GIT_CMD, ['config', USER_EMAIL_CONFIG, TEST_EMAIL], {
-                cwd: testRepo,
-                stdio: 'pipe',
-            });
-            execFileSync(GIT_CMD, ['config', USER_NAME_CONFIG, TEST_USERNAME], {
-                cwd: testRepo,
-                stdio: 'pipe',
-            });
-            fs.writeFileSync(path.join(testRepo, 'test.txt'), 'test');
-            execFileSync(GIT_CMD, ['add', '.'], { cwd: testRepo, stdio: 'pipe' });
-            execFileSync(GIT_CMD, ['commit', '-m', 'init'], { cwd: testRepo, stdio: 'pipe' });
-            const testReason = 'user-approved: testing bypass';
-            execFileSync(SCRIPTS_SAFE_GIT_PATH, ['reset', '--hard', 'HEAD'], {
-                cwd: testRepo,
-                encoding: 'utf-8',
-                env: { ...process.env, LUMENFLOW_FORCE: '1', LUMENFLOW_FORCE_REASON: testReason },
-            });
-            const bypassLog = path.join(testRepo, '.lumenflow', FORCE_BYPASSES_LOG);
-            const logContent = fs.readFileSync(bypassLog, 'utf-8');
-            expect(logContent).toContain(testReason);
-        });
-        it('should print warning when LUMENFLOW_FORCE used without REASON', () => {
-            const testRepo = path.join(tempDir, 'test-repo-no-reason');
-            fs.mkdirSync(testRepo, { recursive: true });
-            execFileSync(GIT_CMD, ['init'], { cwd: testRepo, stdio: 'pipe' });
-            execFileSync(GIT_CMD, ['config', USER_EMAIL_CONFIG, TEST_EMAIL], {
-                cwd: testRepo,
-                stdio: 'pipe',
-            });
-            execFileSync(GIT_CMD, ['config', USER_NAME_CONFIG, TEST_USERNAME], {
-                cwd: testRepo,
-                stdio: 'pipe',
-            });
-            fs.writeFileSync(path.join(testRepo, 'test.txt'), 'test');
-            execFileSync(GIT_CMD, ['add', '.'], { cwd: testRepo, stdio: 'pipe' });
-            execFileSync(GIT_CMD, ['commit', '-m', 'init'], { cwd: testRepo, stdio: 'pipe' });
-            // Execute with LUMENFLOW_FORCE=1 but no reason
-            execFileSync(SCRIPTS_SAFE_GIT_PATH, ['reset', '--hard', 'HEAD'], {
-                cwd: testRepo,
-                encoding: 'utf-8',
-                env: { ...process.env, LUMENFLOW_FORCE: '1' },
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            // Check the bypasslog for the NO_REASON marker
-            const bypassLog = path.join(testRepo, '.lumenflow', FORCE_BYPASSES_LOG);
-            const logContent = fs.readFileSync(bypassLog, 'utf-8');
-            expect(logContent).toContain('NO_REASON');
-        });
-    });
-});

package/dist/__tests__/session-coordinator.test.js

@@ -1,109 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for session-coordinator CLI command
- *
- * WU-1112: INIT-003 Phase 6 - Migrate remaining Tier 1 tools
- *
- * Session coordinator manages agent sessions - starting, stopping,
- * and coordinating handoffs between sessions.
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Import functions under test
-import { parseSessionArgs, SessionCommand, validateSessionCommand, } from '../session-coordinator.js';
-describe('session-coordinator', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('parseSessionArgs', () => {
-        it('should parse start subcommand', () => {
-            const args = parseSessionArgs(['node', 'session-coordinator.js', 'start']);
-            expect(args.command).toBe('start');
-        });
-        it('should parse stop subcommand', () => {
-            const args = parseSessionArgs(['node', 'session-coordinator.js', 'stop']);
-            expect(args.command).toBe('stop');
-        });
-        it('should parse status subcommand', () => {
-            const args = parseSessionArgs(['node', 'session-coordinator.js', 'status']);
-            expect(args.command).toBe('status');
-        });
-        it('should parse handoff subcommand', () => {
-            const args = parseSessionArgs(['node', 'session-coordinator.js', 'handoff']);
-            expect(args.command).toBe('handoff');
-        });
-        it('should parse --wu option', () => {
-            const args = parseSessionArgs(['node', 'session-coordinator.js', 'start', '--wu', 'WU-1112']);
-            expect(args.wuId).toBe('WU-1112');
-        });
-        it('should parse --agent option', () => {
-            const args = parseSessionArgs([
-                'node',
-                'session-coordinator.js',
-                'start',
-                '--agent',
-                'claude-code',
-            ]);
-            expect(args.agent).toBe('claude-code');
-        });
-        it('should parse --reason option for stop', () => {
-            const args = parseSessionArgs([
-                'node',
-                'session-coordinator.js',
-                'stop',
-                '--reason',
-                'Completed work',
-            ]);
-            expect(args.reason).toBe('Completed work');
-        });
-        it('should parse --help flag', () => {
-            const args = parseSessionArgs(['node', 'session-coordinator.js', '--help']);
-            expect(args.help).toBe(true);
-        });
-        it('should default to status when no subcommand given', () => {
-            const args = parseSessionArgs(['node', 'session-coordinator.js']);
-            expect(args.command).toBe('status');
-        });
-    });
-    describe('validateSessionCommand', () => {
-        it('should accept valid start command with wu', () => {
-            const args = { command: 'start', wuId: 'WU-1112' };
-            const result = validateSessionCommand(args);
-            expect(result.valid).toBe(true);
-        });
-        it('should reject start without wu', () => {
-            const args = { command: 'start' };
-            const result = validateSessionCommand(args);
-            expect(result.valid).toBe(false);
-            expect(result.error).toContain('--wu');
-        });
-        it('should accept stop command without reason', () => {
-            const args = { command: 'stop' };
-            const result = validateSessionCommand(args);
-            expect(result.valid).toBe(true);
-        });
-        it('should accept status command', () => {
-            const args = { command: 'status' };
-            const result = validateSessionCommand(args);
-            expect(result.valid).toBe(true);
-        });
-        it('should accept handoff command with wu', () => {
-            const args = { command: 'handoff', wuId: 'WU-1112' };
-            const result = validateSessionCommand(args);
-            expect(result.valid).toBe(true);
-        });
-        it('should reject handoff without wu', () => {
-            const args = { command: 'handoff' };
-            const result = validateSessionCommand(args);
-            expect(result.valid).toBe(false);
-            expect(result.error).toContain('--wu');
-        });
-    });
-    describe('SessionCommand enum', () => {
-        it('should have all expected commands', () => {
-            expect(SessionCommand.START).toBe('start');
-            expect(SessionCommand.STOP).toBe('stop');
-            expect(SessionCommand.STATUS).toBe('status');
-            expect(SessionCommand.HANDOFF).toBe('handoff');
-        });
-    });
-});