vibeman 0.0.2 → 0.0.5

package/dist/runtime/api/workflows/workflow-reducer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/api/workflows/workflow-reducer.test.js

@@ -0,0 +1,247 @@
+import { describe, it, expect } from 'vitest';
+import { reduce, computeNextAction, createInitialState } from './workflow-reducer.js';
+const defaultConfig = {
+    autoQualityChecks: true,
+    requireHumanApproval: true,
+    aiCodeReview: true,
+    stepByStepMode: false,
+    autoCommit: false,
+    retryPolicy: { maxImplementationAttempts: 3 },
+};
+function createTestState(overrides = {}) {
+    const base = createInitialState('wf-test-1', 'task-test-1', defaultConfig);
+    return { ...base, ...overrides, config: { ...base.config, ...overrides.config } };
+}
+describe('workflow-reducer', () => {
+    describe('reduce()', () => {
+        describe('START event', () => {
+            it('transitions from draft to implementing', () => {
+                const state = createTestState({ phase: 'draft' });
+                const event = { type: 'START' };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('implementing');
+                expect(result.effects).toContainEqual({ type: 'EXECUTE_IMPLEMENTATION' });
+                expect(result.effects).toContainEqual({ type: 'SAVE_WORKFLOW' });
+            });
+            it('does nothing if already implementing', () => {
+                const state = createTestState({ phase: 'implementing' });
+                const event = { type: 'START' };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('implementing');
+                expect(result.effects).toHaveLength(0);
+            });
+        });
+        describe('IMPL_SUCCESS event', () => {
+            it('transitions from implementing to validating', () => {
+                const state = createTestState({ phase: 'implementing' });
+                const event = { type: 'IMPL_SUCCESS', executionId: 'exec-1' };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('validating');
+                expect(result.state.executionIds.implementing).toContain('exec-1');
+            });
+            it('triggers validation in non-step-by-step mode', () => {
+                const state = createTestState({ phase: 'implementing' });
+                const event = { type: 'IMPL_SUCCESS' };
+                const result = reduce(state, event);
+                expect(result.effects).toContainEqual({ type: 'EXECUTE_VALIDATION' });
+            });
+            it('does not trigger validation in step-by-step mode', () => {
+                const state = createTestState({
+                    phase: 'implementing',
+                    config: { ...defaultConfig, stepByStepMode: true },
+                });
+                const event = { type: 'IMPL_SUCCESS' };
+                const result = reduce(state, event);
+                expect(result.effects).not.toContainEqual({ type: 'EXECUTE_VALIDATION' });
+            });
+        });
+        describe('IMPL_FAIL event', () => {
+            it('retries if under max attempts', () => {
+                const state = createTestState({
+                    phase: 'implementing',
+                    attempts: { implementing: 0 },
+                });
+                const event = { type: 'IMPL_FAIL', error: 'Test error', canRetry: true };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('implementing');
+                expect(result.state.attempts.implementing).toBe(1);
+                expect(result.state.rerunContext?.reason).toBe('Test error');
+            });
+            it('fails if max attempts exceeded', () => {
+                const state = createTestState({
+                    phase: 'implementing',
+                    attempts: { implementing: 2 },
+                });
+                const event = { type: 'IMPL_FAIL', error: 'Test error', canRetry: true };
+                const result = reduce(state, event);
+                expect(result.state.terminalStatus).toBe('failed');
+                expect(result.state.error).toBe('Test error');
+            });
+            it('fails immediately if canRetry is false', () => {
+                const state = createTestState({
+                    phase: 'implementing',
+                    attempts: { implementing: 0 },
+                });
+                const event = { type: 'IMPL_FAIL', error: 'Test error', canRetry: false };
+                const result = reduce(state, event);
+                expect(result.state.terminalStatus).toBe('failed');
+            });
+        });
+        describe('VALID_SUCCESS event', () => {
+            it('transitions to approved when AI review is enabled', () => {
+                const state = createTestState({
+                    phase: 'validating',
+                    config: { ...defaultConfig, aiCodeReview: true },
+                });
+                const event = {
+                    type: 'VALID_SUCCESS',
+                    results: { overall: true, timestamp: new Date().toISOString(), details: {}, outputs: {} },
+                };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('approved');
+                expect(result.state.qualityResults?.overall).toBe(true);
+            });
+            it('transitions to merging when no approval needed', () => {
+                const state = createTestState({
+                    phase: 'validating',
+                    config: { ...defaultConfig, aiCodeReview: false, requireHumanApproval: false },
+                });
+                const event = {
+                    type: 'VALID_SUCCESS',
+                    results: { overall: true, timestamp: new Date().toISOString(), details: {}, outputs: {} },
+                };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('merging');
+            });
+        });
+        describe('PAUSE event', () => {
+            it('sets terminal status to paused from any active phase', () => {
+                const state = createTestState({ phase: 'implementing' });
+                const event = { type: 'PAUSE' };
+                const result = reduce(state, event);
+                expect(result.state.terminalStatus).toBe('paused');
+                expect(result.effects).toContainEqual({ type: 'STOP_EXECUTION' });
+            });
+        });
+        describe('RESUME event', () => {
+            it('clears terminal status and restores phase', () => {
+                const state = createTestState({
+                    phase: 'implementing',
+                    terminalStatus: 'paused',
+                });
+                const event = { type: 'RESUME' };
+                const result = reduce(state, event);
+                expect(result.state.terminalStatus).toBeNull();
+                expect(result.state.phase).toBe('implementing');
+            });
+        });
+        describe('APPROVE event', () => {
+            it('transitions from approved to merging', () => {
+                const state = createTestState({ phase: 'approved' });
+                const event = { type: 'APPROVE' };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('merging');
+            });
+        });
+        describe('REJECT event', () => {
+            it('transitions from approved back to implementing', () => {
+                const state = createTestState({ phase: 'approved' });
+                const event = { type: 'REJECT', feedback: 'Please fix X' };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('implementing');
+                expect(result.state.rerunContext?.feedback).toBe('Please fix X');
+            });
+        });
+        describe('MERGE_SUCCESS event', () => {
+            it('transitions from merging to done', () => {
+                const state = createTestState({ phase: 'merging' });
+                const event = {
+                    type: 'MERGE_SUCCESS',
+                    prUrl: 'https://github.com/pr/1',
+                    prNumber: 1,
+                };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('done');
+                expect(result.state.links.prUrl).toBe('https://github.com/pr/1');
+                expect(result.state.links.prNumber).toBe(1);
+                expect(result.state.endTime).toBeDefined();
+            });
+        });
+        describe('RETRY event', () => {
+            it('returns to implementing from failed state', () => {
+                const state = createTestState({
+                    phase: 'implementing',
+                    terminalStatus: 'failed',
+                });
+                const event = { type: 'RETRY' };
+                const result = reduce(state, event);
+                expect(result.state.phase).toBe('implementing');
+                expect(result.state.terminalStatus).toBeNull();
+                expect(result.effects).toContainEqual({ type: 'EXECUTE_IMPLEMENTATION' });
+            });
+        });
+    });
+    describe('computeNextAction()', () => {
+        it('returns implementing for draft phase', () => {
+            const state = createTestState({ phase: 'draft' });
+            const action = computeNextAction(state);
+            expect(action).toEqual({ action: 'implementing' });
+        });
+        it('returns validating for validating phase', () => {
+            const state = createTestState({ phase: 'validating' });
+            const action = computeNextAction(state);
+            expect(action).toEqual({ action: 'validating' });
+        });
+        it('returns ai-reviewing for approved phase with aiCodeReview enabled and no result', () => {
+            const state = createTestState({
+                phase: 'approved',
+                config: { ...defaultConfig, aiCodeReview: true },
+            });
+            const action = computeNextAction(state);
+            expect(action).toEqual({ action: 'ai-reviewing' });
+        });
+        it('returns awaiting-approval for approved phase with humanApproval required', () => {
+            const state = createTestState({
+                phase: 'approved',
+                config: { ...defaultConfig, aiCodeReview: false, requireHumanApproval: true },
+            });
+            const action = computeNextAction(state);
+            expect(action).toEqual({ action: 'awaiting-approval' });
+        });
+        it('returns merging for approved phase without approval requirements', () => {
+            const state = createTestState({
+                phase: 'approved',
+                config: { ...defaultConfig, aiCodeReview: false, requireHumanApproval: false },
+            });
+            const action = computeNextAction(state);
+            expect(action).toEqual({ action: 'merging' });
+        });
+        it('returns none for done phase', () => {
+            const state = createTestState({ phase: 'done' });
+            const action = computeNextAction(state);
+            expect(action).toEqual({ action: 'none', reason: 'Workflow completed' });
+        });
+        it('returns implementing with feedback for paused state', () => {
+            const state = createTestState({
+                phase: 'implementing',
+                terminalStatus: 'paused',
+                rerunContext: { reason: 'test', feedback: 'Fix the bug' },
+            });
+            const action = computeNextAction(state);
+            expect(action).toEqual({ action: 'implementing', feedback: 'Fix the bug' });
+        });
+        it('returns implementing with error for failed state', () => {
+            const state = createTestState({
+                phase: 'implementing',
+                terminalStatus: 'failed',
+                failureContext: {
+                    atPhase: 'implementing',
+                    error: 'Build failed',
+                    timestamp: new Date().toISOString(),
+                },
+            });
+            const action = computeNextAction(state);
+            expect(action).toEqual({ action: 'implementing', feedback: 'Build failed' });
+        });
+    });
+});