vibeman 0.0.3 → 0.0.5

package/dist/runtime/api/workflows/workflow-effects.d.ts

@@ -0,0 +1,45 @@
+import type { WorkflowState } from './workflow-schema.js';
+export type WorkflowEffect = {
+    type: 'EXECUTE_IMPLEMENTATION';
+    feedback?: string;
+} | {
+    type: 'EXECUTE_VALIDATION';
+} | {
+    type: 'EXECUTE_AI_REVIEW';
+} | {
+    type: 'EXECUTE_MERGE';
+} | {
+    type: 'EXECUTE_CLEANUP';
+} | {
+    type: 'STOP_EXECUTION';
+} | {
+    type: 'SAVE_WORKFLOW';
+} | {
+    type: 'UPDATE_TASK';
+} | {
+    type: 'EMIT_EVENT';
+    name: string;
+    payload: Record<string, unknown>;
+};
+export interface EffectContext {
+    workflowId: string;
+    taskId: string;
+    state: WorkflowState;
+    executeImplementation: (feedback?: string) => Promise<void>;
+    executeValidation: () => Promise<void>;
+    executeAiReview: () => Promise<void>;
+    executeMerge: () => Promise<void>;
+    executeCleanup: () => Promise<void>;
+    stopExecution: () => Promise<void>;
+    saveWorkflow: (state: WorkflowState) => Promise<void>;
+    updateTask: () => Promise<void>;
+    emit: (name: string, payload: Record<string, unknown>) => void;
+}
+export declare function executeEffects(effects: WorkflowEffect[], context: EffectContext): Promise<void>;
+export interface EffectLogEntry {
+    timestamp: string;
+    effect: WorkflowEffect;
+    workflowId: string;
+    phase: string;
+}
+export declare function createEffectLog(effects: WorkflowEffect[], state: WorkflowState): EffectLogEntry[];

package/dist/runtime/api/workflows/workflow-effects.js

@@ -0,0 +1,49 @@
+// ============================================================================
+// EFFECT EXECUTOR
+// Executes a list of effects using the provided context
+// ============================================================================
+export async function executeEffects(effects, context) {
+    for (const effect of effects) {
+        await executeEffect(effect, context);
+    }
+}
+async function executeEffect(effect, context) {
+    switch (effect.type) {
+        case 'EXECUTE_IMPLEMENTATION':
+            await context.executeImplementation(effect.feedback);
+            break;
+        case 'EXECUTE_VALIDATION':
+            await context.executeValidation();
+            break;
+        case 'EXECUTE_AI_REVIEW':
+            await context.executeAiReview();
+            break;
+        case 'EXECUTE_MERGE':
+            await context.executeMerge();
+            break;
+        case 'EXECUTE_CLEANUP':
+            await context.executeCleanup();
+            break;
+        case 'STOP_EXECUTION':
+            await context.stopExecution();
+            break;
+        case 'SAVE_WORKFLOW':
+            await context.saveWorkflow(context.state);
+            break;
+        case 'UPDATE_TASK':
+            await context.updateTask();
+            break;
+        case 'EMIT_EVENT':
+            context.emit(effect.name, effect.payload);
+            break;
+    }
+}
+export function createEffectLog(effects, state) {
+    const now = new Date().toISOString();
+    return effects.map((effect) => ({
+        timestamp: now,
+        effect,
+        workflowId: state.id,
+        phase: state.phase,
+    }));
+}

package/dist/runtime/api/workflows/workflow-reconciler.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter } from 'events';
+export interface ReconcilerConfig {
+    checkIntervalMs: number;
+    stuckThresholdMs: number;
+    maxReconcileAttempts: number;
+}
+export interface WorkflowSnapshot {
+    id: string;
+    taskId: string;
+    phase: string;
+    lastUpdatedAt: string;
+    terminalStatus: string | null;
+    lastHeartbeat?: string;
+    reconcileAttempts?: number;
+}
+export interface ReconcileAction {
+    workflowId: string;
+    action: 'timeout' | 'retry' | 'fail' | 'skip';
+    reason: string;
+    timestamp: string;
+}
+export declare class WorkflowReconciler extends EventEmitter {
+    private config;
+    private intervalId;
+    private running;
+    private reconcileHistory;
+    private getWorkflowsFn;
+    private onStuckWorkflow;
+    constructor(config: Partial<ReconcilerConfig>, getWorkflows: () => WorkflowSnapshot[], onStuckWorkflow: (workflowId: string, action: ReconcileAction) => Promise<void>);
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    getReconcileHistory(): ReconcileAction[];
+    reconcile(): Promise<ReconcileAction[]>;
+    private checkWorkflow;
+}
+export declare class HeartbeatTracker {
+    private heartbeats;
+    private staleThresholdMs;
+    constructor(staleThresholdMs?: number);
+    recordHeartbeat(workflowId: string, phase: string): void;
+    getLastHeartbeat(workflowId: string): string | undefined;
+    isStale(workflowId: string): boolean;
+    remove(workflowId: string): void;
+    getStaleWorkflows(): string[];
+    clear(): void;
+}
+export declare class IdempotencyGuard {
+    private processedEvents;
+    private ttlMs;
+    private cleanupIntervalId;
+    constructor(ttlMs?: number);
+    start(): void;
+    stop(): void;
+    generateEventKey(workflowId: string, eventType: string, payload?: Record<string, unknown>): string;
+    isProcessed(eventKey: string): boolean;
+    markProcessed(eventKey: string, result: 'success' | 'failure'): void;
+    getProcessedResult(eventKey: string): 'success' | 'failure' | null;
+    withIdempotency<T>(eventKey: string, operation: () => Promise<T>): Promise<{
+        result: T;
+        skipped: boolean;
+    }>;
+    private cleanup;
+    clear(): void;
+}

package/dist/runtime/api/workflows/workflow-reconciler.js

@@ -0,0 +1,226 @@
+import { EventEmitter } from 'events';
+import { log } from '../lib/logger.js';
+const DEFAULT_CONFIG = {
+    checkIntervalMs: 60 * 1000,
+    stuckThresholdMs: 30 * 60 * 1000,
+    maxReconcileAttempts: 3,
+};
+export class WorkflowReconciler extends EventEmitter {
+    constructor(config, getWorkflows, onStuckWorkflow) {
+        super();
+        this.intervalId = null;
+        this.running = false;
+        this.reconcileHistory = [];
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.getWorkflowsFn = getWorkflows;
+        this.onStuckWorkflow = onStuckWorkflow;
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        log.info('Workflow reconciler started', {
+            checkIntervalMs: this.config.checkIntervalMs,
+            stuckThresholdMs: this.config.stuckThresholdMs,
+        }, 'workflow-reconciler');
+        this.intervalId = setInterval(() => {
+            this.reconcile().catch((err) => {
+                log.error('Reconciler tick failed', err, 'workflow-reconciler');
+            });
+        }, this.config.checkIntervalMs);
+        this.reconcile().catch((err) => {
+            log.error('Initial reconcile failed', err, 'workflow-reconciler');
+        });
+    }
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        log.info('Workflow reconciler stopped', {}, 'workflow-reconciler');
+    }
+    isRunning() {
+        return this.running;
+    }
+    getReconcileHistory() {
+        return [...this.reconcileHistory];
+    }
+    async reconcile() {
+        const workflows = this.getWorkflowsFn();
+        const now = Date.now();
+        const actions = [];
+        for (const wf of workflows) {
+            const action = this.checkWorkflow(wf, now);
+            if (action) {
+                actions.push(action);
+                this.reconcileHistory.push(action);
+                if (this.reconcileHistory.length > 100) {
+                    this.reconcileHistory = this.reconcileHistory.slice(-100);
+                }
+                try {
+                    await this.onStuckWorkflow(wf.id, action);
+                    this.emit('workflowReconciled', action);
+                }
+                catch (err) {
+                    log.error('Failed to handle stuck workflow', { workflowId: wf.id, err }, 'workflow-reconciler');
+                }
+            }
+        }
+        if (actions.length > 0) {
+            log.info('Reconciler found stuck workflows', { count: actions.length }, 'workflow-reconciler');
+        }
+        return actions;
+    }
+    checkWorkflow(wf, now) {
+        if (wf.terminalStatus === 'paused' || wf.terminalStatus === 'failed') {
+            return null;
+        }
+        if (wf.phase === 'done') {
+            return null;
+        }
+        const activePhases = ['implementing', 'validating', 'merging'];
+        if (!activePhases.includes(wf.phase)) {
+            return null;
+        }
+        const lastUpdate = new Date(wf.lastHeartbeat || wf.lastUpdatedAt).getTime();
+        const elapsed = now - lastUpdate;
+        if (elapsed < this.config.stuckThresholdMs) {
+            return null;
+        }
+        const attempts = wf.reconcileAttempts || 0;
+        const timestamp = new Date().toISOString();
+        if (attempts >= this.config.maxReconcileAttempts) {
+            return {
+                workflowId: wf.id,
+                action: 'fail',
+                reason: `Exceeded max reconcile attempts (${this.config.maxReconcileAttempts}) after ${Math.round(elapsed / 60000)}min stuck`,
+                timestamp,
+            };
+        }
+        return {
+            workflowId: wf.id,
+            action: 'timeout',
+            reason: `No progress for ${Math.round(elapsed / 60000)}min in phase ${wf.phase}`,
+            timestamp,
+        };
+    }
+}
+// ============================================================================
+// HEARTBEAT TRACKER
+// Tracks heartbeats for active workflow executions
+// ============================================================================
+export class HeartbeatTracker {
+    constructor(staleThresholdMs = 5 * 60 * 1000) {
+        this.heartbeats = new Map();
+        this.staleThresholdMs = staleThresholdMs;
+    }
+    recordHeartbeat(workflowId, phase) {
+        this.heartbeats.set(workflowId, {
+            lastBeat: new Date().toISOString(),
+            phase,
+        });
+    }
+    getLastHeartbeat(workflowId) {
+        return this.heartbeats.get(workflowId)?.lastBeat;
+    }
+    isStale(workflowId) {
+        const entry = this.heartbeats.get(workflowId);
+        if (!entry)
+            return true;
+        const elapsed = Date.now() - new Date(entry.lastBeat).getTime();
+        return elapsed > this.staleThresholdMs;
+    }
+    remove(workflowId) {
+        this.heartbeats.delete(workflowId);
+    }
+    getStaleWorkflows() {
+        const stale = [];
+        const now = Date.now();
+        for (const [id, entry] of this.heartbeats) {
+            const elapsed = now - new Date(entry.lastBeat).getTime();
+            if (elapsed > this.staleThresholdMs) {
+                stale.push(id);
+            }
+        }
+        return stale;
+    }
+    clear() {
+        this.heartbeats.clear();
+    }
+}
+// ============================================================================
+// IDEMPOTENCY GUARD
+// Ensures workflow events are processed only once
+// ============================================================================
+export class IdempotencyGuard {
+    constructor(ttlMs = 60 * 60 * 1000) {
+        this.processedEvents = new Map();
+        this.cleanupIntervalId = null;
+        this.ttlMs = ttlMs;
+    }
+    start() {
+        this.cleanupIntervalId = setInterval(() => {
+            this.cleanup();
+        }, this.ttlMs / 2);
+    }
+    stop() {
+        if (this.cleanupIntervalId) {
+            clearInterval(this.cleanupIntervalId);
+            this.cleanupIntervalId = null;
+        }
+    }
+    generateEventKey(workflowId, eventType, payload) {
+        const payloadHash = payload ? JSON.stringify(payload).slice(0, 100) : '';
+        return `${workflowId}:${eventType}:${payloadHash}`;
+    }
+    isProcessed(eventKey) {
+        return this.processedEvents.has(eventKey);
+    }
+    markProcessed(eventKey, result) {
+        this.processedEvents.set(eventKey, {
+            timestamp: new Date().toISOString(),
+            result,
+        });
+    }
+    getProcessedResult(eventKey) {
+        return this.processedEvents.get(eventKey)?.result ?? null;
+    }
+    async withIdempotency(eventKey, operation) {
+        if (this.isProcessed(eventKey)) {
+            const prevResult = this.getProcessedResult(eventKey);
+            log.debug('Skipping duplicate event', { eventKey, previousResult: prevResult }, 'idempotency-guard');
+            return { result: undefined, skipped: true };
+        }
+        try {
+            const result = await operation();
+            this.markProcessed(eventKey, 'success');
+            return { result, skipped: false };
+        }
+        catch (err) {
+            this.markProcessed(eventKey, 'failure');
+            throw err;
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        const toRemove = [];
+        for (const [key, entry] of this.processedEvents) {
+            const elapsed = now - new Date(entry.timestamp).getTime();
+            if (elapsed > this.ttlMs) {
+                toRemove.push(key);
+            }
+        }
+        for (const key of toRemove) {
+            this.processedEvents.delete(key);
+        }
+        if (toRemove.length > 0) {
+            log.debug('Cleaned up expired idempotency keys', { count: toRemove.length }, 'idempotency-guard');
+        }
+    }
+    clear() {
+        this.processedEvents.clear();
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { WorkflowState, WorkflowEvent, WorkflowConfig } from './workflow-schema.js';
+import type { WorkflowEffect } from './workflow-effects.js';
+export interface ReducerResult {
+    state: WorkflowState;
+    effects: WorkflowEffect[];
+}
+export declare function reduce(state: WorkflowState, event: WorkflowEvent): ReducerResult;
+export type NextAction = {
+    action: 'implementing';
+    feedback?: string;
+} | {
+    action: 'validating';
+} | {
+    action: 'ai-reviewing';
+} | {
+    action: 'awaiting-approval';
+} | {
+    action: 'merging';
+} | {
+    action: 'cleanup';
+} | {
+    action: 'none';
+    reason: string;
+};
+export declare function computeNextAction(state: WorkflowState): NextAction;
+export declare function createInitialState(workflowId: string, taskId: string, config: WorkflowConfig): WorkflowState;

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

@@ -0,0 +1,288 @@
+import { getNextPhase } from './workflow-schema.js';
+export function reduce(state, event) {
+    const now = new Date().toISOString();
+    const nextPhase = getNextPhase(state, event);
+    // Invalid transition - no change
+    if (nextPhase === null) {
+        return { state, effects: [] };
+    }
+    // Compute new state based on event type
+    let newState = {
+        ...state,
+        lastUpdatedAt: now,
+    };
+    const effects = [];
+    // Handle terminal statuses
+    if (nextPhase === 'paused') {
+        newState = {
+            ...newState,
+            terminalStatus: 'paused',
+            error: 'Paused by user',
+        };
+        effects.push({ type: 'STOP_EXECUTION' });
+        effects.push({ type: 'EMIT_EVENT', name: 'workflowPaused', payload: { workflowId: state.id } });
+        effects.push({ type: 'SAVE_WORKFLOW' });
+        return { state: newState, effects };
+    }
+    if (nextPhase === 'failed') {
+        const errorMsg = 'error' in event ? event.error : 'Unknown error';
+        newState = {
+            ...newState,
+            terminalStatus: 'failed',
+            error: errorMsg,
+            failureContext: {
+                atPhase: state.phase,
+                error: errorMsg,
+                timestamp: now,
+            },
+        };
+        effects.push({
+            type: 'EMIT_EVENT',
+            name: 'workflowFailed',
+            payload: { workflowId: state.id, error: errorMsg },
+        });
+        effects.push({ type: 'SAVE_WORKFLOW' });
+        return { state: newState, effects };
+    }
+    // Clear terminal status if resuming
+    if (event.type === 'RESUME' || event.type === 'RETRY') {
+        newState = {
+            ...newState,
+            terminalStatus: null,
+            error: undefined,
+        };
+    }
+    // Phase transition
+    if (nextPhase !== state.phase) {
+        newState = {
+            ...newState,
+            phase: nextPhase,
+        };
+        effects.push({
+            type: 'EMIT_EVENT',
+            name: 'workflowPhaseChanged',
+            payload: { workflowId: state.id, oldPhase: state.phase, newPhase: nextPhase },
+        });
+    }
+    // Event-specific state updates and effects
+    switch (event.type) {
+        case 'START':
+            effects.push({ type: 'EXECUTE_IMPLEMENTATION' });
+            break;
+        case 'IMPL_SUCCESS':
+            if (event.executionId) {
+                newState = updateExecutionIds(newState, 'implementing', event.executionId);
+            }
+            if (!state.config.stepByStepMode) {
+                effects.push({ type: 'EXECUTE_VALIDATION' });
+            }
+            break;
+        case 'IMPL_FAIL':
+            newState = incrementAttempts(newState, 'implementing');
+            if (nextPhase === 'implementing' && event.canRetry) {
+                newState = {
+                    ...newState,
+                    rerunContext: {
+                        reason: event.error,
+                        previousExecutionId: getLastExecutionId(state, 'implementing'),
+                    },
+                };
+                if (!state.config.stepByStepMode) {
+                    effects.push({ type: 'EXECUTE_IMPLEMENTATION', feedback: event.error });
+                }
+            }
+            break;
+        case 'VALID_SUCCESS':
+            newState = {
+                ...newState,
+                qualityResults: event.results,
+            };
+            if (nextPhase === 'approved' && state.config.aiCodeReview && !state.config.stepByStepMode) {
+                effects.push({ type: 'EXECUTE_AI_REVIEW' });
+            }
+            if (nextPhase === 'merging' && !state.config.stepByStepMode) {
+                effects.push({ type: 'EXECUTE_MERGE' });
+            }
+            break;
+        case 'VALID_FAIL':
+            if (event.results) {
+                newState = { ...newState, qualityResults: event.results };
+            }
+            newState = {
+                ...newState,
+                rerunContext: {
+                    reason: `Validation failed: ${event.error}`,
+                    previousExecutionId: getLastExecutionId(state, 'implementing'),
+                },
+            };
+            if (!state.config.stepByStepMode) {
+                effects.push({ type: 'EXECUTE_IMPLEMENTATION', feedback: event.error });
+            }
+            break;
+        case 'REVIEW_DONE':
+            newState = {
+                ...newState,
+                aiReviewResult: event.result,
+            };
+            if (event.result.executionId) {
+                newState = updateExecutionIds(newState, 'approved', event.result.executionId);
+            }
+            effects.push({ type: 'UPDATE_TASK' });
+            break;
+        case 'REVIEW_SKIP':
+            effects.push({ type: 'UPDATE_TASK' });
+            break;
+        case 'APPROVE':
+            if (!state.config.stepByStepMode) {
+                effects.push({ type: 'EXECUTE_MERGE' });
+            }
+            break;
+        case 'REJECT':
+            newState = {
+                ...newState,
+                rerunContext: {
+                    reason: 'Rejected by reviewer',
+                    feedback: event.feedback,
+                    previousExecutionId: getLastExecutionId(state, 'implementing'),
+                },
+            };
+            if (!state.config.stepByStepMode) {
+                effects.push({ type: 'EXECUTE_IMPLEMENTATION', feedback: event.feedback });
+            }
+            break;
+        case 'MERGE_SUCCESS':
+            newState = {
+                ...newState,
+                links: {
+                    ...newState.links,
+                    prUrl: event.prUrl,
+                    prNumber: event.prNumber,
+                },
+                endTime: now,
+            };
+            effects.push({ type: 'EXECUTE_CLEANUP' });
+            effects.push({
+                type: 'EMIT_EVENT',
+                name: 'workflowCompleted',
+                payload: { workflowId: state.id },
+            });
+            break;
+        case 'MERGE_FAIL':
+            // Stay in approved, let user retry
+            break;
+        case 'CLEAN_SUCCESS':
+            newState = { ...newState, endTime: now };
+            break;
+        case 'COMPLETE_MANUAL':
+            newState = {
+                ...newState,
+                phase: 'done',
+                endTime: now,
+            };
+            effects.push({
+                type: 'EMIT_EVENT',
+                name: 'workflowCompleted',
+                payload: { workflowId: state.id, manual: true },
+            });
+            break;
+        case 'RETRY':
+            newState = {
+                ...newState,
+                rerunContext: {
+                    reason: 'Manual retry',
+                    previousExecutionId: getLastExecutionId(state, 'implementing'),
+                },
+            };
+            effects.push({ type: 'EXECUTE_IMPLEMENTATION' });
+            break;
+    }
+    effects.push({ type: 'SAVE_WORKFLOW' });
+    return { state: newState, effects };
+}
+export function computeNextAction(state) {
+    const { phase, terminalStatus, config } = state;
+    // If paused, suggest resume to implementing (or last phase)
+    if (terminalStatus === 'paused') {
+        return { action: 'implementing', feedback: state.rerunContext?.feedback };
+    }
+    // If failed, suggest retry
+    if (terminalStatus === 'failed') {
+        return { action: 'implementing', feedback: state.failureContext?.error };
+    }
+    switch (phase) {
+        case 'draft':
+            return { action: 'implementing' };
+        case 'implementing':
+            // In step-by-step mode, this phase means we're waiting for user to continue
+            // The phase mapping already moved 'implemented' -> 'validating'
+            // So if we're still in 'implementing', the execution is in progress
+            return { action: 'none', reason: 'Implementation in progress' };
+        case 'validating':
+            // Validation phase: run the quality checks
+            return { action: 'validating' };
+        case 'approved':
+            // Check if AI review is needed and not done yet
+            if (config.aiCodeReview && !state.aiReviewResult) {
+                return { action: 'ai-reviewing' };
+            }
+            // If human approval required, wait for user to click approve
+            if (config.requireHumanApproval) {
+                return { action: 'awaiting-approval' };
+            }
+            // Otherwise proceed to merge
+            return { action: 'merging' };
+        case 'merging':
+            // Execute merge
+            return { action: 'merging' };
+        case 'done':
+            return { action: 'none', reason: 'Workflow completed' };
+        default:
+            return { action: 'none', reason: 'Unknown phase' };
+    }
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+function incrementAttempts(state, phase) {
+    const current = state.attempts[phase] ?? 0;
+    return {
+        ...state,
+        attempts: {
+            ...state.attempts,
+            [phase]: current + 1,
+        },
+    };
+}
+function updateExecutionIds(state, phase, executionId) {
+    const current = state.executionIds[phase] ?? [];
+    return {
+        ...state,
+        executionIds: {
+            ...state.executionIds,
+            [phase]: [...current, executionId],
+        },
+    };
+}
+function getLastExecutionId(state, phase) {
+    const ids = state.executionIds[phase] ?? [];
+    return ids[ids.length - 1];
+}
+// ============================================================================
+// STATE FACTORY
+// Creates initial workflow state from task and config
+// ============================================================================
+export function createInitialState(workflowId, taskId, config) {
+    const now = new Date().toISOString();
+    return {
+        id: workflowId,
+        taskId,
+        phase: 'draft',
+        terminalStatus: null,
+        startTime: now,
+        lastUpdatedAt: now,
+        attempts: {},
+        executionIds: {},
+        links: {},
+        config,
+    };
+}