edsger 0.41.0 → 0.41.2

package/dist/commands/workflow/pipeline-runner.js

@@ -0,0 +1,393 @@
+/**
+ * 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 { updateFeatureStatusForPhase } from '../../api/features/index.js';
+import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
+import { logPipelineStart, logPhaseResult, logPipelineComplete, shouldContinuePipeline, } from '../../utils/pipeline-logger.js';
+import { handleTestFailuresWithRetry } from '../../phases/functional-testing/test-retry-handler.js';
+import { handleCodeRefineWithRetry } from '../../phases/code-refine/retry-handler.js';
+import { handlePullRequestCreation } from '../../phases/pull-request/handler.js';
+/**
+ * Run pipeline based on execution mode
+ */
+export const runPipelineByMode = async (options, config, executionMode) => {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`🚀 Starting pipeline with mode: ${executionMode} for feature: ${featureId}`);
+        console.log(`📋 Execution mode details:`);
+        console.log(`  - Mode value: "${executionMode}"`);
+        console.log(`  - Mode type: ${typeof executionMode}`);
+        console.log(`  - Mode === 'only_feature_analysis': ${executionMode === 'only_feature_analysis'}`);
+    }
+    switch (executionMode) {
+        // Complete pipeline
+        case 'full_pipeline':
+        case 'from_feature_analysis':
+            if (verbose) {
+                console.log(`  ➡️ Matched: full_pipeline or from_feature_analysis - running complete pipeline`);
+            }
+            return await runFromFeatureAnalysis(options, config);
+        // Feature Analysis
+        case 'only_feature_analysis':
+            if (verbose) {
+                console.log(`  ➡️ Matched: only_feature_analysis - running analysis only`);
+            }
+            return await runOnlyFeatureAnalysis(options, config);
+        // Technical Design
+        case 'only_technical_design':
+            return await runOnlyTechnicalDesign(options, config);
+        case 'from_technical_design':
+            return await runFromTechnicalDesign(options, config);
+        // Code Implementation
+        case 'only_code_implementation':
+            return await runOnlyCodeImplementation(options, config);
+        case 'from_code_implementation':
+            return await runFromCodeImplementation(options, config);
+        // Functional Testing
+        case 'only_functional_testing':
+            return await runOnlyFunctionalTesting(options, config);
+        case 'from_functional_testing':
+            return await runFromFunctionalTesting(options, config);
+        // Code Refine
+        case 'only_code_refine':
+            return await runOnlyCodeRefine(options, config);
+        // Code Review
+        case 'only_code_review':
+            return await runOnlyCodeReview(options, config);
+        case 'from_code_review':
+            return await runFromCodeReview(options, config);
+        default:
+            throw new Error(`Unsupported execution mode: ${executionMode}`);
+    }
+};
+/**
+ * Run complete pipeline for a feature using functional composition (legacy)
+ */
+export const runCompletePipeline = (options, config) => {
+    return async () => {
+        return await runFromFeatureAnalysis(options, config);
+    };
+};
+// Helper functions for different execution patterns
+/**
+ * Run only feature analysis phase
+ */
+const runOnlyFeatureAnalysis = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    const analysisResult = await runFeatureAnalysisPhase(options, config);
+    results.push(logPhaseResult(analysisResult, verbose));
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run only technical design phase
+ */
+const runOnlyTechnicalDesign = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    const designResult = await runTechnicalDesignPhase(options, config);
+    results.push(logPhaseResult(designResult, verbose));
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run only code implementation phase
+ */
+const runOnlyCodeImplementation = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    const implementationResult = await runCodeImplementationPhase(options, config);
+    results.push(logPhaseResult(implementationResult, verbose));
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run only functional testing phase
+ */
+const runOnlyFunctionalTesting = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    const testingResult = await runFunctionalTestingPhase(options, config);
+    results.push(logPhaseResult(testingResult, verbose));
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run from feature analysis to end
+ */
+const runFromFeatureAnalysis = async (options, config) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. Feature Analysis
+    const analysisResult = await runFeatureAnalysisPhase(options, config);
+    results.push(logPhaseResult(analysisResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
+    }
+    // 2. Technical Design
+    const designResult = await runTechnicalDesignPhase(options, config);
+    results.push(logPhaseResult(designResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
+    }
+    // 3. Code Implementation
+    const implementationResult = await runCodeImplementationPhase(options, config);
+    results.push(logPhaseResult(implementationResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
+    }
+    // 4. Functional Testing with retry loop for bug fixes
+    const testingResult = await handleTestFailuresWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    // Update final status based on functional testing result
+    const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
+    await updateFeatureStatusForPhase({ mcpServerUrl, mcpToken }, featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    // Create pull request if tests passed
+    if (testingResult.status === 'success') {
+        const prCreated = await handlePullRequestCreation({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            results,
+            testingResult,
+            verbose,
+        });
+        // Continue with code review and refine workflow only if PR was created
+        if (prCreated) {
+            await continueWithCodeReviewAndRefine(options, config, results, verbose);
+        }
+        else {
+            if (verbose) {
+                console.log('⚠️ Skipping code review and refine workflow: pull request creation failed');
+            }
+        }
+    }
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run from technical design to end
+ */
+const runFromTechnicalDesign = async (options, config) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. Technical Design
+    const designResult = await runTechnicalDesignPhase(options, config);
+    results.push(logPhaseResult(designResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
+    }
+    // 2. Code Implementation
+    const implementationResult = await runCodeImplementationPhase(options, config);
+    results.push(logPhaseResult(implementationResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
+    }
+    // 3. Functional Testing with retry loop for bug fixes
+    const testingResult = await handleTestFailuresWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    // Update final status based on functional testing result
+    const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
+    await updateFeatureStatusForPhase({ mcpServerUrl, mcpToken }, featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    // Create pull request if tests passed
+    if (testingResult.status === 'success') {
+        const prCreated = await handlePullRequestCreation({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            results,
+            testingResult,
+            verbose,
+        });
+        // Continue with code review and refine workflow only if PR was created
+        if (prCreated) {
+            await continueWithCodeReviewAndRefine(options, config, results, verbose);
+        }
+        else {
+            if (verbose) {
+                console.log('⚠️ Skipping code review and refine workflow: pull request creation failed');
+            }
+        }
+    }
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run from code implementation to end
+ */
+const runFromCodeImplementation = async (options, config) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. Code Implementation
+    const implementationResult = await runCodeImplementationPhase(options, config);
+    results.push(logPhaseResult(implementationResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
+    }
+    // 2. Functional Testing with retry loop for bug fixes
+    const testingResult = await handleTestFailuresWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    // Update final status based on functional testing result
+    const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
+    await updateFeatureStatusForPhase({ mcpServerUrl, mcpToken }, featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    // Create pull request if tests passed
+    if (testingResult.status === 'success') {
+        const prCreated = await handlePullRequestCreation({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            results,
+            testingResult,
+            verbose,
+        });
+        // Continue with code review and refine workflow only if PR was created
+        if (prCreated) {
+            await continueWithCodeReviewAndRefine(options, config, results, verbose);
+        }
+        else {
+            if (verbose) {
+                console.log('⚠️ Skipping code review and refine workflow: pull request creation failed');
+            }
+        }
+    }
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run from functional testing to end
+ */
+const runFromFunctionalTesting = async (options, config) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. Functional Testing with retry loop for bug fixes
+    const testingResult = await handleTestFailuresWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    // Update final status based on functional testing result
+    const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
+    await updateFeatureStatusForPhase({ mcpServerUrl, mcpToken }, featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    // Create pull request if tests passed
+    if (testingResult.status === 'success') {
+        const prCreated = await handlePullRequestCreation({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            results,
+            testingResult,
+            verbose,
+        });
+        // Continue with code review and refine workflow only if PR was created
+        if (prCreated) {
+            await continueWithCodeReviewAndRefine(options, config, results, verbose);
+        }
+        else {
+            if (verbose) {
+                console.log('⚠️ Skipping code review and refine workflow: pull request creation failed');
+            }
+        }
+    }
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run only code refine phase (refine code based on PR feedback)
+ * Includes automatic retry loop for verification failures
+ */
+const runOnlyCodeRefine = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // Code Refine with automatic retry for verification failures
+    await handleCodeRefineWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run only code review phase (review PR and create review comments)
+ */
+const runOnlyCodeReview = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // Code Review - analyze PR and create review comments
+    const reviewResult = await runCodeReviewPhase(options, config);
+    results.push(logPhaseResult(reviewResult, verbose));
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run from code review to end (code-review → code-refine → code-refine-verification)
+ */
+const runFromCodeReview = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. Code Review - analyze PR and create review comments
+    const reviewResult = await runCodeReviewPhase(options, config);
+    results.push(logPhaseResult(reviewResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
+    }
+    // 2. Code Refine with automatic retry for verification failures
+    await handleCodeRefineWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Continue with code review and refine after PR creation
+ * This is the post-PR workflow: code-review → code-refine → code-refine-verification → code-testing
+ */
+const continueWithCodeReviewAndRefine = async (options, config, results, verbose) => {
+    if (verbose) {
+        console.log('\n🔄 Continuing with code review and refine workflow...');
+    }
+    // 1. Code Review - analyze PR and create review comments
+    const reviewResult = await runCodeReviewPhase(options, config);
+    results.push(logPhaseResult(reviewResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return;
+    }
+    // 2. Code Refine with automatic retry for verification failures
+    await handleCodeRefineWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    if (!shouldContinuePipeline(results)) {
+        return;
+    }
+    // 3. Code Testing - write automated tests for the implemented code
+    if (verbose) {
+        console.log('\n📝 Starting code testing phase...');
+    }
+    const testingResult = await runCodeTestingPhase(options, config);
+    results.push(logPhaseResult(testingResult, verbose));
+};

package/dist/commands/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/commands/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 '../../workflow-runner/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/commands/workflow/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/commands/workflow/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';
+}