vibeman 0.0.5 → 0.0.6

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

@@ -1,45 +0,0 @@
-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

@@ -1,49 +0,0 @@
-// ============================================================================
-// 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

@@ -1,65 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,288 +0,0 @@
-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,
-    };
-}