vibeman 0.0.5 → 0.0.7

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

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

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

@@ -1,247 +0,0 @@
-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' });
-        });
-    });
-});