edsger 0.30.0 → 0.30.2

package/dist/workflow-runner/core/pipeline-evaluator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pipeline result evaluation utilities for workflow processor
+ * Pure functions for evaluating pipeline execution results
+ */
+import type { PipelineResult } from '../../types/pipeline.js';
+export declare const evaluatePipelineResults: (results: readonly PipelineResult[]) => boolean;
+export declare const hasAnyPipelineFailures: (results: readonly PipelineResult[]) => boolean;
+export declare const countSuccessfulPhases: (results: readonly PipelineResult[]) => number;
+export declare const countFailedPhases: (results: readonly PipelineResult[]) => number;
+export declare const getFailedPhases: (results: readonly PipelineResult[]) => PipelineResult[];
+export declare const getSuccessfulPhases: (results: readonly PipelineResult[]) => PipelineResult[];
+export declare const getFirstFailure: (results: readonly PipelineResult[]) => PipelineResult | undefined;
+export declare const getLastPhaseResult: (results: readonly PipelineResult[]) => PipelineResult | undefined;
+export declare const isPipelineFullySuccessful: (results: readonly PipelineResult[]) => boolean;
+export declare const isPipelinePartiallySuccessful: (results: readonly PipelineResult[]) => boolean;
+export declare const isPipelineCompleteFailure: (results: readonly PipelineResult[]) => boolean;
+export declare const isPipelineEmpty: (results: readonly PipelineResult[]) => boolean;
+export interface PipelineStats {
+    readonly total: number;
+    readonly successful: number;
+    readonly failed: number;
+    readonly successRate: number;
+}
+export declare const calculatePipelineStats: (results: readonly PipelineResult[]) => PipelineStats;

package/dist/workflow-runner/core/pipeline-evaluator.js

@@ -0,0 +1,32 @@
+/**
+ * Pipeline result evaluation utilities for workflow processor
+ * Pure functions for evaluating pipeline execution results
+ */
+// Pipeline result evaluation (pure)
+export const evaluatePipelineResults = (results) => results.every((result) => result.status === 'success');
+export const hasAnyPipelineFailures = (results) => results.some((result) => result.status !== 'success');
+export const countSuccessfulPhases = (results) => results.filter((result) => result.status === 'success').length;
+export const countFailedPhases = (results) => results.filter((result) => result.status !== 'success').length;
+export const getFailedPhases = (results) => results.filter((result) => result.status !== 'success');
+export const getSuccessfulPhases = (results) => results.filter((result) => result.status === 'success');
+export const getFirstFailure = (results) => results.find((result) => result.status !== 'success');
+export const getLastPhaseResult = (results) => results.length > 0 ? results[results.length - 1] : undefined;
+// Pipeline completion status
+export const isPipelineFullySuccessful = (results) => results.length > 0 && evaluatePipelineResults(results);
+export const isPipelinePartiallySuccessful = (results) => results.length > 0 &&
+    countSuccessfulPhases(results) > 0 &&
+    hasAnyPipelineFailures(results);
+export const isPipelineCompleteFailure = (results) => results.length > 0 && countSuccessfulPhases(results) === 0;
+export const isPipelineEmpty = (results) => results.length === 0;
+export const calculatePipelineStats = (results) => {
+    const total = results.length;
+    const successful = countSuccessfulPhases(results);
+    const failed = countFailedPhases(results);
+    const successRate = total > 0 ? successful / total : 0;
+    return {
+        total,
+        successful,
+        failed,
+        successRate,
+    };
+};

package/dist/workflow-runner/core/state-manager.d.ts

@@ -0,0 +1,24 @@
+/**
+ * State management utilities for workflow processor
+ * Pure functions for handling feature processing states
+ */
+export interface FeatureProcessingState {
+    readonly featureId: string;
+    readonly retryCount: number;
+    readonly lastAttempt: Date;
+    readonly status: 'processing' | 'completed' | 'failed';
+    readonly featureUpdatedAt?: string;
+}
+export interface WorkflowStats {
+    readonly totalProcessed: number;
+    readonly completed: number;
+    readonly failed: number;
+    readonly processing: number;
+    readonly isRunning: boolean;
+}
+export declare const createInitialState: () => Map<string, FeatureProcessingState>;
+export declare const createProcessingState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
+export declare const createCompletedState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
+export declare const createFailedState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
+export declare const updateFeatureState: (states: Map<string, FeatureProcessingState>, featureId: string, updateFn: (currentState?: FeatureProcessingState) => FeatureProcessingState) => Map<string, FeatureProcessingState>;
+export declare const calculateStats: (states: Map<string, FeatureProcessingState>, isRunning: boolean) => WorkflowStats;

package/dist/workflow-runner/core/state-manager.js

@@ -0,0 +1,42 @@
+/**
+ * State management utilities for workflow processor
+ * Pure functions for handling feature processing states
+ */
+// State creation functions (pure)
+export const createInitialState = () => new Map();
+export const createProcessingState = (featureId, currentState) => ({
+    featureId,
+    retryCount: currentState ? currentState.retryCount + 1 : 1,
+    lastAttempt: new Date(),
+    status: 'processing',
+});
+export const createCompletedState = (featureId, currentState) => ({
+    featureId,
+    retryCount: currentState ? currentState.retryCount : 1,
+    lastAttempt: new Date(),
+    status: 'completed',
+});
+export const createFailedState = (featureId, currentState) => ({
+    featureId,
+    retryCount: currentState ? currentState.retryCount : 1,
+    lastAttempt: new Date(),
+    status: 'failed',
+});
+// State update function (pure)
+export const updateFeatureState = (states, featureId, updateFn) => {
+    const newStates = new Map(states);
+    const currentState = newStates.get(featureId);
+    newStates.set(featureId, updateFn(currentState));
+    return newStates;
+};
+// Statistics calculation (pure)
+export const calculateStats = (states, isRunning) => {
+    const stateArray = Array.from(states.values());
+    return {
+        totalProcessed: stateArray.length,
+        completed: stateArray.filter((s) => s.status === 'completed').length,
+        failed: stateArray.filter((s) => s.status === 'failed').length,
+        processing: stateArray.filter((s) => s.status === 'processing').length,
+        isRunning,
+    };
+};

package/dist/workflow-runner/core/workflow-logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Logging utilities for workflow processor
+ * Centralized logging functions for workflow operations
+ */
+import type { FeatureInfo } from '../../types/features.js';
+import type { PipelineResult } from '../../types/pipeline.js';
+export declare const logProcessingStart: (feature: FeatureInfo, verbose?: boolean) => void;
+export declare const logRetryInfo: (featureName: string, retryCount: number, maxRetries: number) => void;
+export declare const logPipelineResults: (results: readonly PipelineResult[]) => void;
+export declare const logProcessorStart: (productId: string, pollInterval: number) => void;
+export declare const logProcessorReady: () => void;
+export declare const logProcessorStop: () => void;
+export declare const logFeatureSuccess: (featureName: string) => void;
+export declare const logFeatureFailed: (featureName: string) => void;
+export declare const logFeatureError: (featureName: string, error: unknown) => void;
+export declare const logNoFeaturesFound: () => void;
+export declare const logAllFeaturesProcessed: () => void;
+export declare const logSkippingProcessing: (processingCount: number) => void;
+export declare const logPollingError: (error: unknown) => void;
+export declare const logProcessNextFeatureError: (error: unknown) => void;

package/dist/workflow-runner/core/workflow-logger.js

@@ -0,0 +1,65 @@
+/**
+ * Logging utilities for workflow processor
+ * Centralized logging functions for workflow operations
+ */
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+export const logProcessingStart = (feature, verbose) => {
+    logInfo(`🎯 Processing feature: ${feature.name} (${feature.id})`);
+    if (verbose) {
+        logInfo(`   Description: ${feature.description}`);
+        logInfo(`   Last updated: ${feature.updated_at}`);
+    }
+};
+export const logRetryInfo = (featureName, retryCount, maxRetries) => {
+    if (retryCount < maxRetries) {
+        logInfo(`🔄 Will retry feature ${featureName} (attempt ${retryCount + 1}/${maxRetries})`);
+    }
+    else {
+        logError(`⛔ Max retries reached for feature ${featureName}, marking as permanently failed`);
+    }
+};
+export const logPipelineResults = (results) => {
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 Pipeline Results Summary');
+    console.log('='.repeat(60));
+    results.forEach((result, index) => {
+        const statusIcon = result.status === 'success' ? '✅' : '❌';
+        console.log(`${index + 1}. ${statusIcon} ${result.phase}: ${result.message}`);
+    });
+    console.log('='.repeat(60) + '\n');
+};
+export const logProcessorStart = (productId, pollInterval) => {
+    logInfo('🚀 Starting workflow processor...');
+    logInfo(`📋 Product ID: ${productId}`);
+    logInfo(`🔄 Poll interval: ${pollInterval}ms`);
+};
+export const logProcessorReady = () => {
+    logInfo('✅ Workflow processor started and monitoring for new features');
+};
+export const logProcessorStop = () => {
+    logInfo('⏹️  Workflow processor stopped');
+};
+export const logFeatureSuccess = (featureName) => {
+    logSuccess(`✅ Feature ${featureName} completed successfully!`);
+};
+export const logFeatureFailed = (featureName) => {
+    logError(`❌ Feature ${featureName} failed in pipeline`);
+};
+export const logFeatureError = (featureName, error) => {
+    logError(`❌ Error processing feature ${featureName}: ${error instanceof Error ? error.message : String(error)}`);
+};
+export const logNoFeaturesFound = () => {
+    logInfo('🔍 No ready_for_dev features found, continuing to monitor...');
+};
+export const logAllFeaturesProcessed = () => {
+    logInfo('🔄 All current features are processed or being processed, continuing to monitor...');
+};
+export const logSkippingProcessing = (processingCount) => {
+    logInfo(`⏳ Skipping feature fetching as ${processingCount} feature(s) are currently being processed`);
+};
+export const logPollingError = (error) => {
+    logError(`Error in polling cycle: ${error instanceof Error ? error.message : String(error)}`);
+};
+export const logProcessNextFeatureError = (error) => {
+    logError(`Error in processNextFeature: ${error instanceof Error ? error.message : String(error)}`);
+};

package/dist/workflow-runner/executors/phase-executor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Phase execution logic for pipeline runner
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { PipelinePhaseOptions, PipelineResult, PhaseConfig } from '../../types/pipeline.js';
+export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };

package/dist/workflow-runner/executors/phase-executor.js

@@ -0,0 +1,248 @@
+/**
+ * Phase execution logic for pipeline runner
+ */
+import { updateFeatureStatusForPhase } from '../../api/features/index.js';
+import { phaseConfigs } from '../config/phase-configs.js';
+import { getChecklistsForPhase, validateChecklistsForPhase, validateRequiredChecklistResults, processChecklistResultsFromResponse, processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+// Higher-order function for phase execution
+export const createPhaseRunner = (phaseConfig) => async (options, config) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    const { name, checkRequirements, execute, requirementsError } = phaseConfig;
+    // Track phase duration for logging
+    const phaseStartTime = Date.now();
+    try {
+        // Check requirements
+        const hasRequirements = await checkRequirements();
+        if (!hasRequirements) {
+            return {
+                featureId,
+                phase: name,
+                status: 'error',
+                message: requirementsError,
+            };
+        }
+        // Update feature status to reflect current phase
+        await updateFeatureStatusForPhase({ mcpServerUrl, mcpToken }, featureId, name, verbose);
+        if (verbose) {
+            console.log(`🎯 Starting ${name} for: ${featureId}`);
+        }
+        // Log phase start
+        await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            eventType: 'phase_started',
+            phase: name.replace(/-/g, '_'),
+            result: 'info',
+            metadata: {
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
+        // Fetch checklists for this phase as context
+        let checklistContext = null;
+        try {
+            checklistContext = await getChecklistsForPhase(options, name);
+            if (verbose && checklistContext.checklists.length > 0) {
+                console.log(`📋 Found ${checklistContext.checklists.length} checklists for ${name} phase`);
+            }
+        }
+        catch (checklistError) {
+            // Always log checklist fetch errors, not just in verbose mode
+            console.log(`⚠️  Failed to fetch checklists for ${name} phase: ${checklistError instanceof Error ? checklistError.message : String(checklistError)}`);
+            // Log more details in verbose mode
+            if (verbose && checklistError instanceof Error) {
+                console.log(`   Details: ${checklistError.stack}`);
+            }
+        }
+        // Execute the phase with checklist context
+        const result = await execute(options, config, checklistContext);
+        // Process checklist results from phase response if phase was successful
+        if (result.status === 'success') {
+            try {
+                // Extract checklist_item_results from result data if available (new format)
+                const checklistItemResults = result.data?.checklist_item_results;
+                if (checklistItemResults && Array.isArray(checklistItemResults)) {
+                    const processResult = await processChecklistItemResultsFromResponse(options, name, checklistItemResults, verbose);
+                    if (verbose) {
+                        if (processResult.created > 0) {
+                            console.log(`📋 Processed ${processResult.created} checklist item results from ${name} phase`);
+                        }
+                        if (processResult.errors.length > 0) {
+                            console.log(`⚠️  ${processResult.errors.length} errors processing checklist item results`);
+                            processResult.errors.forEach((error) => console.log(`   - ${error}`));
+                        }
+                    }
+                }
+                else {
+                    // Fallback to old format for backward compatibility
+                    const checklistResults = result.data?.checklist_results;
+                    if (checklistResults && Array.isArray(checklistResults)) {
+                        const processResult = await processChecklistResultsFromResponse(options, checklistResults, verbose);
+                        if (verbose) {
+                            if (processResult.created > 0) {
+                                console.log(`📋 Processed ${processResult.created} checklist results from ${name} phase (legacy format)`);
+                            }
+                            if (processResult.errors.length > 0) {
+                                console.log(`⚠️  ${processResult.errors.length} errors processing checklist results`);
+                                processResult.errors.forEach((error) => console.log(`   - ${error}`));
+                            }
+                        }
+                    }
+                }
+            }
+            catch (processError) {
+                if (verbose) {
+                    console.log(`⚠️  Failed to process checklist results from ${name} phase: ${processError instanceof Error ? processError.message : String(processError)}`);
+                }
+            }
+        }
+        // Strictly validate checklist results after phase execution
+        let checklistValidation = null;
+        if (result.status === 'success') {
+            try {
+                // First perform strict validation - this will fail if checklists exist but have no results
+                const strictValidation = await validateRequiredChecklistResults(options, name, verbose);
+                if (!strictValidation.success) {
+                    // If validation fails, return error immediately - don't continue pipeline
+                    return {
+                        featureId,
+                        phase: name,
+                        status: 'error',
+                        message: `Checklist validation failed: ${strictValidation.error}`,
+                        data: {
+                            ...result,
+                            checklist_context: checklistContext,
+                            checklist_validation_error: strictValidation.error,
+                            missing_checklists: strictValidation.missingChecklists,
+                        },
+                    };
+                }
+                // If strict validation passes, get detailed validation info for logging
+                checklistValidation = await validateChecklistsForPhase(options, name);
+                if (verbose) {
+                    console.log(`📋 Checklist validation: ${checklistValidation.summary}`);
+                }
+                // Log completion status
+                if (checklistValidation.checklists_validation.length > 0) {
+                    const completedCount = checklistValidation.checklists_validation.filter((v) => v.is_completed).length;
+                    const totalCount = checklistValidation.checklists_validation.length;
+                    if (verbose) {
+                        console.log(`📋 Checklist results status: ${completedCount}/${totalCount} checklists have results`);
+                    }
+                    // Log any incomplete checklists
+                    if (!checklistValidation.all_completed) {
+                        checklistValidation.checklists_validation.forEach((validation) => {
+                            if (!validation.is_completed) {
+                                console.log(`   - ${validation.checklist_name} (${validation.role}): ${validation.status}`);
+                            }
+                        });
+                    }
+                }
+            }
+            catch (validationError) {
+                // If validation itself fails, treat as error and stop pipeline
+                return {
+                    featureId,
+                    phase: name,
+                    status: 'error',
+                    message: `Checklist validation error: ${validationError instanceof Error ? validationError.message : String(validationError)}`,
+                    data: {
+                        ...result,
+                        checklist_context: checklistContext,
+                        checklist_validation_error: validationError instanceof Error
+                            ? validationError.message
+                            : String(validationError),
+                    },
+                };
+            }
+        }
+        // Log phase completion
+        const phaseEndTime = Date.now();
+        const phaseDuration = phaseEndTime - phaseStartTime;
+        if (result.status === 'success') {
+            await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                featureId,
+                eventType: 'phase_completed',
+                phase: name.replace(/-/g, '_'),
+                result: 'success',
+                metadata: {
+                    duration_ms: phaseDuration,
+                    iterations: result.data?.iterations,
+                    artifacts: result.data,
+                    checklist_validation: checklistValidation,
+                },
+            }, verbose);
+        }
+        else {
+            // Extract additional failure details from result data
+            const failureMetadata = {
+                duration_ms: phaseDuration,
+            };
+            // For verification phases, include suggestions and details
+            if (name.includes('verification') &&
+                result.data &&
+                typeof result.data === 'object') {
+                const data = result.data;
+                if (data.suggestions) {
+                    failureMetadata.suggestions = data.suggestions;
+                }
+                if (data.unresolvedCommentDetails ||
+                    data.unresolved_comment_details) {
+                    failureMetadata.unresolved_comment_details =
+                        data.unresolvedCommentDetails || data.unresolved_comment_details;
+                }
+                if (data.unresolvedComments !== undefined ||
+                    data.unresolved_comments !== undefined) {
+                    failureMetadata.unresolved_comments =
+                        data.unresolvedComments ?? data.unresolved_comments;
+                }
+            }
+            await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                featureId,
+                eventType: 'phase_failed',
+                phase: name.replace(/-/g, '_'),
+                result: 'error',
+                metadata: failureMetadata,
+                errorMessage: result.summary || result.message || 'Phase execution failed',
+            }, verbose);
+        }
+        return {
+            featureId,
+            phase: name,
+            status: result.status === 'success' ? 'success' : 'error',
+            message: result.status === 'success'
+                ? `${name.replace('-', ' ')} completed successfully`
+                : `${name.replace('-', ' ')} failed`,
+            data: {
+                ...result,
+                checklist_context: checklistContext,
+                checklist_validation: checklistValidation,
+            },
+        };
+    }
+    catch (error) {
+        // Log phase failure for exceptions
+        const phaseEndTime = Date.now();
+        const phaseDuration = phaseEndTime - phaseStartTime;
+        await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            eventType: 'phase_failed',
+            phase: name.replace(/-/g, '_'),
+            result: 'error',
+            metadata: {
+                duration_ms: phaseDuration,
+                error_type: 'exception',
+            },
+            errorMessage: error instanceof Error ? error.message : String(error),
+        }, verbose);
+        return {
+            featureId,
+            phase: name,
+            status: 'error',
+            message: `${name.replace('-', ' ')} failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+// Create phase runners using the configuration
+const [runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase,] = phaseConfigs.map(createPhaseRunner);
+// Export individual phase runners for granular control
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };

package/dist/workflow-runner/feature-workflow-runner.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Feature workflow runner with execution mode support
+ * Main entry point for running workflow pipelines with different execution modes
+ */
+import { EdsgerConfig } from '../types/index.js';
+import { PipelinePhaseOptions, PipelineResult, ExecutionMode } from '../types/pipeline.js';
+/**
+ * Run workflow for a feature based on its execution_mode configuration
+ */
+export declare function runFeatureWorkflow(options: PipelinePhaseOptions, config: EdsgerConfig): Promise<readonly PipelineResult[]>;
+/**
+ * Run workflow for a feature with explicit execution mode override
+ */
+export declare function runFeatureWorkflowWithMode(options: PipelinePhaseOptions, config: EdsgerConfig, executionMode: ExecutionMode): Promise<readonly PipelineResult[]>;
+/**
+ * Get available execution modes
+ */
+export declare function getAvailableExecutionModes(): ExecutionMode[];
+/**
+ * Validate execution mode
+ */
+export declare function isValidExecutionMode(mode: string): mode is ExecutionMode;
+/**
+ * Get execution mode description
+ */
+export declare function getExecutionModeDescription(mode: ExecutionMode): string;

package/dist/workflow-runner/feature-workflow-runner.js

@@ -0,0 +1,119 @@
+/**
+ * Feature workflow runner with execution mode support
+ * Main entry point for running workflow pipelines with different execution modes
+ */
+import { runPipelineByMode } from './pipeline-runner.js';
+import { getFeature } from '../api/features/get-feature.js';
+import { logError, logInfo } from '../utils/logger.js';
+/**
+ * Run workflow for a feature based on its execution_mode configuration
+ */
+export async function runFeatureWorkflow(options, config) {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    try {
+        // 1. Get feature details to check execution_mode
+        if (verbose) {
+            logInfo(`🔍 Fetching feature configuration for: ${featureId}`);
+        }
+        const feature = await getFeature(mcpServerUrl, mcpToken, featureId, verbose);
+        // Debug log raw feature data
+        if (verbose) {
+            logInfo(`🔍 Feature data from API:`);
+            logInfo(`  - execution_mode (raw): ${feature.execution_mode}`);
+            logInfo(`  - execution_mode (type): ${typeof feature.execution_mode}`);
+            logInfo(`  - is valid: ${isValidExecutionMode(feature.execution_mode || '')}`);
+        }
+        // 2. Determine execution mode (default to full_pipeline if not set)
+        const executionMode = isValidExecutionMode(feature.execution_mode || '')
+            ? feature.execution_mode
+            : 'full_pipeline';
+        if (verbose) {
+            logInfo(`📋 Selected execution mode: ${executionMode}`);
+            logInfo(`📋 Mode description: ${getExecutionModeDescription(executionMode)}`);
+        }
+        // 3. Run pipeline based on execution mode
+        return await runPipelineByMode(options, config, executionMode);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to run feature workflow: ${errorMessage}`);
+        // Return error result
+        return [
+            {
+                featureId,
+                phase: 'workflow-initialization',
+                status: 'error',
+                message: `Workflow initialization failed: ${errorMessage}`,
+            },
+        ];
+    }
+}
+/**
+ * Run workflow for a feature with explicit execution mode override
+ */
+export async function runFeatureWorkflowWithMode(options, config, executionMode) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        logInfo(`🚀 Running workflow with explicit mode: ${executionMode} for feature: ${featureId}`);
+    }
+    try {
+        return await runPipelineByMode(options, config, executionMode);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to run feature workflow with mode ${executionMode}: ${errorMessage}`);
+        return [
+            {
+                featureId,
+                phase: 'workflow-execution',
+                status: 'error',
+                message: `Workflow execution failed: ${errorMessage}`,
+            },
+        ];
+    }
+}
+/**
+ * Get available execution modes
+ */
+export function getAvailableExecutionModes() {
+    return [
+        'full_pipeline',
+        'only_feature_analysis',
+        'only_technical_design',
+        'only_code_implementation',
+        'only_functional_testing',
+        'only_code_refine',
+        'only_code_review',
+        'from_feature_analysis',
+        'from_technical_design',
+        'from_code_implementation',
+        'from_functional_testing',
+        'from_code_review',
+    ];
+}
+/**
+ * Validate execution mode
+ */
+export function isValidExecutionMode(mode) {
+    return getAvailableExecutionModes().includes(mode);
+}
+/**
+ * Get execution mode description
+ */
+export function getExecutionModeDescription(mode) {
+    const descriptions = {
+        full_pipeline: 'Execute complete workflow: analysis → design → implementation → testing',
+        only_feature_analysis: 'Execute only: feature analysis',
+        only_technical_design: 'Execute only: technical design',
+        only_code_implementation: 'Execute only: code implementation',
+        only_functional_testing: 'Execute only: functional testing',
+        only_code_refine: 'Execute only: code refine (address PR review feedback and verify resolution)',
+        only_code_review: 'Execute only: code review (review PR code and create review comments)',
+        from_feature_analysis: 'Execute from feature analysis to end: analysis → design → implementation → testing',
+        from_technical_design: 'Execute from technical design to end: design → implementation → testing',
+        from_code_implementation: 'Execute from code implementation to end: implementation → testing',
+        from_functional_testing: 'Execute from functional testing to end: testing',
+        from_code_review: 'Execute from code review to end: code-review → code-refine → code-refine-verification',
+    };
+    return descriptions[mode] || 'Unknown execution mode';
+}

package/dist/workflow-runner/index.d.ts

@@ -0,0 +1,2 @@
+export * from './workflow-processor.js';
+export * from './pipeline-runner.js';

package/dist/workflow-runner/index.js

@@ -0,0 +1,2 @@
+export * from './workflow-processor.js';
+export * from './pipeline-runner.js';

package/dist/workflow-runner/pipeline-runner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pipeline runner for executing development workflow phases
+ * Complete pipeline flow:
+ *   feature-analysis → technical-design → code-implementation →
+ *   functional-testing → pull-request → code-review → code-refine → code-refine-verification
+ * Uses functional programming principles
+ */
+import { EdsgerConfig } from '../types/index.js';
+import { PipelinePhaseOptions, PipelineResult, ExecutionMode } from '../types/pipeline.js';
+/**
+ * Run pipeline based on execution mode
+ */
+export declare const runPipelineByMode: (options: PipelinePhaseOptions, config: EdsgerConfig, executionMode: ExecutionMode) => Promise<readonly PipelineResult[]>;
+/**
+ * Run complete pipeline for a feature using functional composition (legacy)
+ */
+export declare const runCompletePipeline: (options: PipelinePhaseOptions, config: EdsgerConfig) => () => Promise<readonly PipelineResult[]>;