edsger 0.2.1 → 0.2.3

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>;
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, };

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

@@ -0,0 +1,183 @@
+/**
+ * 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';
+// 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;
+    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}`);
+        }
+        // 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);
+        console.log({
+            result,
+        });
+        console.log({
+            status: result.status,
+        });
+        console.log({
+            data: result.data,
+        });
+        console.log({
+            checklist_item_results: result.data?.checklist_item_results,
+        });
+        // 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),
+                    },
+                };
+            }
+        }
+        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) {
+        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,] = phaseConfigs.map(createPhaseRunner);
+// Export individual phase runners for granular control
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, };

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

@@ -0,0 +1,8 @@
+/**
+ * Stage execution logic for pipeline runner
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { PipelineStageOptions, PipelineResult, StageConfig } from '../../types/pipeline.js';
+export declare const createStageRunner: (stageConfig: StageConfig) => (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+declare const runFeatureAnalysisStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage, };

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

@@ -0,0 +1,49 @@
+/**
+ * Stage execution logic for pipeline runner
+ */
+import { updateFeatureStatusForStage } from '../../api/features/index.js';
+import { stageConfigs } from '../config/stage-configs.js';
+// Higher-order function for stage execution
+export const createStageRunner = (stageConfig) => async (options, config) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    const { name, checkRequirements, execute, requirementsError } = stageConfig;
+    try {
+        // Check requirements
+        const hasRequirements = await checkRequirements();
+        if (!hasRequirements) {
+            return {
+                featureId,
+                stage: name,
+                status: 'error',
+                message: requirementsError,
+            };
+        }
+        // Update feature status to reflect current stage
+        await updateFeatureStatusForStage({ mcpServerUrl, mcpToken }, featureId, name, verbose);
+        if (verbose) {
+            console.log(`🎯 Starting ${name} for: ${featureId}`);
+        }
+        const result = await execute(options, config);
+        return {
+            featureId,
+            stage: name,
+            status: result.status === 'success' ? 'success' : 'error',
+            message: result.status === 'success'
+                ? `${name.replace('-', ' ')} completed successfully`
+                : `${name.replace('-', ' ')} failed`,
+            data: result,
+        };
+    }
+    catch (error) {
+        return {
+            featureId,
+            stage: name,
+            status: 'error',
+            message: `${name.replace('-', ' ')} failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+// Create stage runners using the configuration
+const [runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage,] = stageConfigs.map(createStageRunner);
+// Export individual stage runners for granular control
+export { runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage, };

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

@@ -0,0 +1,17 @@
+/**
+ * Feature fetching and status management service
+ */
+import { FeatureStatus } from '../types.js';
+import { type FeatureInfo } from '../api/features.js';
+/**
+ * Fetch features with ready_for_dev status for a product
+ */
+export declare function fetchReadyForDevFeatures(mcpServerUrl: string, mcpToken: string, productId: string, verbose?: boolean): Promise<FeatureInfo[]>;
+/**
+ * Map pipeline stage to feature status
+ */
+export declare function getStatusForStage(stage: string): FeatureStatus;
+/**
+ * Update feature status based on pipeline stage
+ */
+export declare function updateFeatureStatusForStage(mcpServerUrl: string, mcpToken: string, featureId: string, stage: string, verbose?: boolean): Promise<boolean>;

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

@@ -0,0 +1,60 @@
+/**
+ * Feature fetching and status management service
+ */
+import { logInfo, logError } from '../logger.js';
+import { updateFeatureStatus, } from '../api/features.js';
+import { callMcpEndpoint } from '../api/mcp-client.js';
+/**
+ * Fetch features with ready_for_dev status for a product
+ */
+export async function fetchReadyForDevFeatures(mcpServerUrl, mcpToken, productId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`📋 Fetching ready_for_dev features for product: ${productId}`);
+        }
+        const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/list', {
+            product_id: productId,
+            status: 'ready_for_dev',
+        }));
+        const features = result?.features || [];
+        if (verbose) {
+            logInfo(`✅ Found ${features.length} ready_for_dev features`);
+            features.forEach((feature, index) => {
+                logInfo(`   ${index + 1}. ${feature.name} (${feature.id})`);
+            });
+        }
+        return features;
+    }
+    catch (error) {
+        logError(`❌ Error fetching features: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Map pipeline stage to feature status
+ */
+export function getStatusForStage(stage) {
+    switch (stage) {
+        case 'feature-analysis':
+            return 'feature_analysis';
+        case 'technical-design':
+            return 'technical_design';
+        case 'code-implementation':
+            return 'code_implementation';
+        case 'functional-testing':
+            return 'testing_in_progress';
+        case 'testing-passed':
+            return 'testing_passed';
+        case 'testing-failed':
+            return 'testing_failed';
+        default:
+            return 'backlog';
+    }
+}
+/**
+ * Update feature status based on pipeline stage
+ */
+export async function updateFeatureStatusForStage(mcpServerUrl, mcpToken, featureId, stage, verbose) {
+    const status = getStatusForStage(stage);
+    return await updateFeatureStatus(mcpServerUrl, mcpToken, featureId, status, verbose);
+}

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,113 @@
+/**
+ * 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',
+        'from_feature_analysis',
+        'from_technical_design',
+        'from_code_implementation',
+        'from_functional_testing',
+    ];
+}
+/**
+ * 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',
+        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',
+    };
+    return descriptions[mode] || 'Unknown execution mode';
+}

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

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

package/dist/workflow-runner/index.js

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

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

@@ -1,25 +1,15 @@
 /**
- * Pipeline runner for executing development workflow stages
+ * Pipeline runner for executing development workflow phases
  * Coordinates feature-analysis -> technical-design -> code-implementation -> functional-testing
  * Uses functional programming principles
  */
-import { EdsgerConfig } from '../types.js';
-export interface PipelineStageOptions {
-    readonly featureId: string;
-    readonly mcpServerUrl: string;
-    readonly mcpToken: string;
-    readonly verbose?: boolean;
-}
-export interface PipelineResult {
-    readonly featureId: string;
-    readonly stage: string;
-    readonly status: 'success' | 'error';
-    readonly message: string;
-    readonly data?: unknown;
-}
-declare const runFeatureAnalysisStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+import { EdsgerConfig } from '../types/index.js';
+import { PipelinePhaseOptions, PipelineResult, ExecutionMode } from '../types/pipeline.js';
 /**
- * Run complete pipeline for a feature using functional composition
+ * Run pipeline based on execution mode
  */
-export declare const runCompletePipeline: (options: PipelineStageOptions, config: EdsgerConfig) => () => Promise<readonly PipelineResult[]>;
-export { runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage, };
+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[]>;