edsger 0.2.1 → 0.2.3

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

@@ -1,273 +1,264 @@
 /**
- * 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 { analyzeFeatureWithMCP, checkFeatureAnalysisRequirements, } from '../feature-analysis/analyzer.js';
-import { generateTechnicalDesign, checkTechnicalDesignRequirements, } from '../technical-design/analyzer.js';
-import { implementFeatureCode, checkCodeImplementationRequirements, } from '../code-implementation/analyzer.js';
-import { runFunctionalTesting, checkFunctionalTestingRequirements, } from '../functional-testing/analyzer.js';
-import { updateFeatureStatusForStage } from './status-updater.js';
-import { createPullRequest, updateFeatureWithPullRequest, } from '../pull-request/creator.js';
-import { getFeatureDetails } from './feature-fetcher.js';
-import { fixTestFailures, checkBugFixingRequirements, } from '../bug-fixing/analyzer.js';
-// Pipeline stage configurations
-const stageConfigs = [
-    {
-        name: 'feature-analysis',
-        checkRequirements: checkFeatureAnalysisRequirements,
-        execute: analyzeFeatureWithMCP,
-        requirementsError: 'Feature analysis requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
-    },
-    {
-        name: 'technical-design',
-        checkRequirements: checkTechnicalDesignRequirements,
-        execute: generateTechnicalDesign,
-        requirementsError: 'Technical design requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
-    },
-    {
-        name: 'code-implementation',
-        checkRequirements: checkCodeImplementationRequirements,
-        execute: implementFeatureCode,
-        requirementsError: 'Code implementation requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
-    },
-    {
-        name: 'functional-testing',
-        checkRequirements: checkFunctionalTestingRequirements,
-        execute: runFunctionalTesting,
-        requirementsError: 'Functional testing requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
-    },
-];
-// Higher-order function for stage execution
-const createStageRunner = (stageConfig) => async (options, config) => {
+import { updateFeatureStatusForPhase } from '../api/features/index.js';
+import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, } 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 { 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);
+        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;
-    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,
-        };
+    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);
     }
-    catch (error) {
-        return {
+    // 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') {
+        await handlePullRequestCreation({
             featureId,
-            stage: name,
-            status: 'error',
-            message: `${name.replace('-', ' ')} failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
+            mcpServerUrl,
+            mcpToken,
+            results,
+            testingResult,
+            verbose,
+        });
     }
+    return logPipelineComplete(results, verbose);
 };
-// Create stage runners using the configuration
-const [runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage,] = stageConfigs.map(createStageRunner);
-// Pipeline execution utilities
-const logPipelineStart = (featureId, verbose) => {
-    if (verbose) {
-        console.log(`🚀 Starting complete pipeline for feature: ${featureId}`);
-        console.log('📋 Pipeline stages: feature-analysis → technical-design → code-implementation → functional-testing');
+/**
+ * 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);
     }
-};
-const logStageResult = (result, verbose) => {
-    if (verbose) {
-        const statusIcon = result.status === 'success' ? '✅' : '❌';
-        console.log(`${statusIcon} ${result.stage}: ${result.message}`);
+    // 2. Code Implementation
+    const implementationResult = await runCodeImplementationPhase(options, config);
+    results.push(logPhaseResult(implementationResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
     }
-    return result;
-};
-const logPipelineComplete = (results, verbose) => {
-    if (verbose) {
-        const lastResult = results[results.length - 1];
-        const featureId = lastResult?.featureId;
-        if (lastResult?.status === 'success') {
-            console.log(`✅ Complete pipeline finished successfully for feature: ${featureId}`);
-        }
-        else {
-            console.log(`❌ Pipeline failed at ${lastResult?.stage}: ${lastResult?.message}`);
-        }
+    // 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') {
+        await handlePullRequestCreation({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            results,
+            testingResult,
+            verbose,
+        });
     }
-    return results;
-};
-// Pure function to check if pipeline should continue
-const shouldContinuePipeline = (results) => {
-    const lastResult = results[results.length - 1];
-    return lastResult?.status === 'success';
+    return logPipelineComplete(results, verbose);
 };
 /**
- * Run complete pipeline for a feature using functional composition
+ * Run from code implementation to end
  */
-export const runCompletePipeline = (options, config) => {
-    const { featureId, verbose } = options;
-    return async () => {
-        logPipelineStart(featureId, verbose);
-        const results = [];
-        // Feature Analysis
-        const analysisResult = await runFeatureAnalysisStage(options, config);
-        results.push(logStageResult(analysisResult, verbose));
-        if (!shouldContinuePipeline(results)) {
-            return logPipelineComplete(results, verbose);
-        }
-        // Technical Design
-        const designResult = await runTechnicalDesignStage(options, config);
-        results.push(logStageResult(designResult, verbose));
-        if (!shouldContinuePipeline(results)) {
-            return logPipelineComplete(results, verbose);
-        }
-        // Code Implementation
-        const implementationResult = await runCodeImplementationStage(options, config);
-        results.push(logStageResult(implementationResult, verbose));
-        if (!shouldContinuePipeline(results)) {
-            return logPipelineComplete(results, verbose);
-        }
-        // Functional Testing with retry loop for bug fixes
-        const MAX_FIX_ATTEMPTS = 3;
-        let testingResult;
-        let fixAttempt = 0;
-        do {
-            // Run functional testing
-            testingResult = await runFunctionalTestingStage(options, config);
-            results.push(logStageResult(testingResult, verbose));
-            // If tests failed and we haven't exceeded max attempts, try to fix
-            if (testingResult.status === 'error' && fixAttempt < MAX_FIX_ATTEMPTS) {
-                fixAttempt++;
-                if (verbose) {
-                    console.log(`🔧 Tests failed. Attempting to fix bugs (Attempt ${fixAttempt}/${MAX_FIX_ATTEMPTS})...`);
-                }
-                // Check if bug fixing requirements are met
-                const hasBugFixingReqs = await checkBugFixingRequirements();
-                if (!hasBugFixingReqs) {
-                    if (verbose) {
-                        console.log('⚠️ Bug fixing requirements not met. Skipping automatic fixes.');
-                    }
-                    break;
-                }
-                // Extract test errors from the testing result
-                const testErrors = testingResult.data?.testResult || testingResult.message;
-                // Run bug fixing
-                const fixResult = await fixTestFailures({
-                    featureId,
-                    mcpServerUrl: options.mcpServerUrl,
-                    mcpToken: options.mcpToken,
-                    testErrors,
-                    attemptNumber: fixAttempt,
-                    verbose,
-                }, config);
-                if (fixResult.status === 'success') {
-                    if (verbose) {
-                        console.log(`✅ Bug fixes applied. Re-running tests...`);
-                        if (fixResult.filesFixed && fixResult.filesFixed.length > 0) {
-                            console.log(`   Files fixed: ${fixResult.filesFixed.join(', ')}`);
-                        }
-                    }
-                    // Remove the previous failed test result from results
-                    results.pop();
-                    // Update status to indicate we're retrying tests
-                    await updateFeatureStatusForStage({ mcpServerUrl: options.mcpServerUrl, mcpToken: options.mcpToken }, featureId, 'functional-testing', verbose);
-                }
-                else {
-                    if (verbose) {
-                        console.log(`❌ Bug fixing failed: ${fixResult.message}`);
-                    }
-                    break;
-                }
-            }
-            else {
-                // Tests passed or max attempts reached
-                break;
-            }
-        } while (fixAttempt <= MAX_FIX_ATTEMPTS);
-        // Log if max attempts reached
-        if (testingResult.status === 'error' &&
-            fixAttempt >= MAX_FIX_ATTEMPTS &&
-            verbose) {
-            console.log(`⚠️ Maximum fix attempts (${MAX_FIX_ATTEMPTS}) reached. Tests still failing.`);
-        }
-        // Update final status based on functional testing result
-        const { mcpServerUrl, mcpToken } = options;
-        const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-        await updateFeatureStatusForStage({ mcpServerUrl, mcpToken }, featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
-        // Create pull request if tests passed
-        if (testingResult.status === 'success') {
-            if (verbose) {
-                console.log('🔄 Creating pull request for successful feature...');
-            }
-            // Get feature details for PR creation
-            const getFeature = getFeatureDetails(featureId, {
-                mcpServerUrl,
-                mcpToken,
-                verbose,
-            });
-            const feature = await getFeature();
-            if (feature) {
-                // Get GitHub configuration from environment
-                const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
-                const githubOwner = process.env.GITHUB_OWNER;
-                const githubRepo = process.env.GITHUB_REPO;
-                if (githubToken && githubOwner && githubRepo) {
-                    const prResult = await createPullRequest({
-                        githubToken,
-                        owner: githubOwner,
-                        repo: githubRepo,
-                        baseBranch: 'main',
-                        verbose,
-                    }, {
-                        id: feature.id,
-                        name: feature.name,
-                        description: feature.description,
-                        productId: feature.product_id,
-                        // Get technical design and test result from previous stages
-                        technicalDesign: results.find((r) => r.stage === 'technical-design')?.data?.technicalDesign,
-                        testResult: testingResult.data?.testResult,
-                        testReportUrl: testingResult.data?.testReport
-                            ?.testReportUrl,
-                    });
-                    if (prResult.success && prResult.pullRequestUrl) {
-                        // Update feature with PR URL and status
-                        await updateFeatureWithPullRequest(mcpServerUrl, mcpToken, featureId, prResult.pullRequestUrl, verbose);
-                        if (verbose) {
-                            console.log(`✅ Pull request created and feature updated to ready_for_review`);
-                        }
-                    }
-                    else {
-                        if (verbose) {
-                            console.log(`⚠️ Pull request creation failed: ${prResult.error}`);
-                        }
-                    }
-                }
-                else {
-                    if (verbose) {
-                        console.log('⚠️ GitHub configuration not found. Skipping pull request creation.');
-                        console.log('   Set GITHUB_TOKEN, GITHUB_OWNER, and GITHUB_REPO environment variables.');
-                    }
-                }
-            }
-            else {
-                if (verbose) {
-                    console.log('⚠️ Could not fetch feature details for pull request creation');
-                }
-            }
-        }
+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') {
+        await handlePullRequestCreation({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            results,
+            testingResult,
+            verbose,
+        });
+    }
+    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') {
+        await handlePullRequestCreation({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            results,
+            testingResult,
+            verbose,
+        });
+    }
+    return logPipelineComplete(results, verbose);
 };
-// Export individual stage runners for granular control
-export { runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage, };

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

@@ -0,0 +1,18 @@
+/**
+ * Pipeline execution logic for feature development workflow
+ */
+import { EdsgerConfig } from '../types.js';
+import { PipelineStageOptions, PipelineResult } from './types.js';
+/**
+ * Run the complete pipeline for a feature
+ */
+export declare function runCompletePipeline(options: PipelineStageOptions, config: EdsgerConfig, githubConfig?: {
+    githubToken: string;
+    githubOwner: string;
+    githubRepo: string;
+    githubBaseBranch?: string;
+}): Promise<PipelineResult[]>;
+/**
+ * Log pipeline results summary
+ */
+export declare function logPipelineResults(results: readonly PipelineResult[]): void;