edsger 0.41.1 → 0.41.2

package/dist/workflow-runner/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/workflow-runner/workflow-processor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Main workflow processor for continuous feature development
+ * Monitors for ready_for_dev features and processes them through the complete pipeline
+ * Uses functional programming principles
+ */
+import { EdsgerConfig } from '../types/index.js';
+import { type WorkflowStats } from './core/state-manager.js';
+export interface WorkflowOptions {
+    readonly productId: string;
+    readonly mcpServerUrl: string;
+    readonly mcpToken: string;
+    readonly pollInterval?: number;
+    readonly maxRetries?: number;
+    readonly verbose?: boolean;
+}
+export type { FeatureProcessingState, WorkflowStats, } from './core/state-manager.js';
+/**
+ * Workflow processor using functional programming principles
+ */
+export declare class WorkflowProcessor {
+    private readonly options;
+    private readonly config;
+    private isRunning;
+    private processedFeatures;
+    private pollTimer?;
+    constructor(options: WorkflowOptions, config: EdsgerConfig);
+    /**
+     * Start the workflow processor
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the workflow processor
+     */
+    stop(): void;
+    /**
+     * Process the next available feature using functional composition
+     */
+    private processNextFeature;
+    /**
+     * Process a single feature through the complete pipeline using functional composition
+     */
+    private processFeature;
+    /**
+     * Get current processing statistics using pure function
+     */
+    getStats(): WorkflowStats;
+}
+/**
+ * Create and start a workflow processor using functional composition
+ */
+export declare const startWorkflowProcessor: (options: WorkflowOptions, config: EdsgerConfig) => () => Promise<WorkflowProcessor>;
+export { createInitialState, updateFeatureState, createProcessingState, createCompletedState, createFailedState, calculateStats, } from './core/state-manager.js';
+export { shouldProcessFeature, findNextFeature } from './core/feature-filter.js';
+export { evaluatePipelineResults } from './core/pipeline-evaluator.js';

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

@@ -0,0 +1,170 @@
+/**
+ * Main workflow processor for continuous feature development
+ * Monitors for ready_for_dev features and processes them through the complete pipeline
+ * Uses functional programming principles
+ */
+import { getReadyForDevFeatures } from '../api/features/index.js';
+import { runFeatureWorkflow } from './feature-workflow-runner.js';
+import { logInfo } from '../utils/logger.js';
+// Import core modules
+import { createInitialState, updateFeatureState, createProcessingState, createCompletedState, createFailedState, calculateStats, } from './core/state-manager.js';
+import { findNextFeature } from './core/feature-filter.js';
+import { evaluatePipelineResults } from './core/pipeline-evaluator.js';
+import { logProcessingStart, logRetryInfo, logPipelineResults, logProcessorStart, logProcessorReady, logProcessorStop, logFeatureSuccess, logFeatureFailed, logFeatureError, logNoFeaturesFound, logAllFeaturesProcessed, logSkippingProcessing, logPollingError, logProcessNextFeatureError, } from './core/workflow-logger.js';
+/**
+ * Workflow processor using functional programming principles
+ */
+export class WorkflowProcessor {
+    options;
+    config;
+    isRunning = false;
+    processedFeatures = createInitialState();
+    pollTimer;
+    constructor(options, config) {
+        this.options = {
+            pollInterval: 30000, // 30 seconds default
+            maxRetries: 3,
+            verbose: false, // default value
+            ...options,
+        };
+        this.config = config;
+    }
+    /**
+     * Start the workflow processor
+     */
+    async start() {
+        if (this.isRunning) {
+            logInfo('Workflow processor is already running');
+            return;
+        }
+        this.isRunning = true;
+        logProcessorStart(this.options.productId, this.options.pollInterval);
+        // Initial check
+        await this.processNextFeature();
+        // Set up polling for new features
+        this.pollTimer = setInterval(() => {
+            this.processNextFeature().catch((error) => {
+                logPollingError(error);
+            });
+        }, this.options.pollInterval);
+        logProcessorReady();
+    }
+    /**
+     * Stop the workflow processor
+     */
+    stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = undefined;
+        }
+        logProcessorStop();
+    }
+    /**
+     * Process the next available feature using functional composition
+     */
+    async processNextFeature() {
+        try {
+            // Skip feature fetching if there are any features currently being processed
+            const stats = calculateStats(this.processedFeatures, this.isRunning);
+            if (stats.processing > 0) {
+                if (this.options.verbose) {
+                    logSkippingProcessing(stats.processing);
+                }
+                return;
+            }
+            // Fetch features using unified API
+            const features = await getReadyForDevFeatures(this.options.mcpServerUrl, this.options.mcpToken, this.options.productId, this.options.verbose);
+            if (features.length === 0) {
+                if (this.options.verbose) {
+                    logNoFeaturesFound();
+                }
+                return;
+            }
+            // Find next feature to process using pure functions
+            const nextFeature = findNextFeature(features, this.processedFeatures, this.options.maxRetries);
+            if (!nextFeature) {
+                if (this.options.verbose) {
+                    logAllFeaturesProcessed();
+                }
+                return;
+            }
+            // Process the feature
+            await this.processFeature(nextFeature);
+        }
+        catch (error) {
+            logProcessNextFeatureError(error);
+        }
+    }
+    /**
+     * Process a single feature through the complete pipeline using functional composition
+     */
+    async processFeature(feature) {
+        const featureId = feature.id;
+        // Check if this is a reprocess due to feature update
+        const existingState = this.processedFeatures.get(featureId);
+        if (existingState &&
+            existingState.status === 'completed' &&
+            this.options.verbose) {
+            logInfo(`🔄 Reprocessing feature "${feature.name}" - detected status change`);
+            if (feature.updated_at) {
+                logInfo(`  Previous process: ${existingState.lastAttempt.toISOString()}`);
+                logInfo(`  Feature updated: ${feature.updated_at}`);
+            }
+        }
+        // Update state to processing using pure function
+        this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createProcessingState(featureId, currentState));
+        logProcessingStart(feature, this.options.verbose);
+        try {
+            // Run pipeline using feature workflow with execution mode support
+            const results = await runFeatureWorkflow({
+                featureId,
+                mcpServerUrl: this.options.mcpServerUrl,
+                mcpToken: this.options.mcpToken,
+                verbose: this.options.verbose,
+            }, this.config);
+            // Evaluate results using pure function
+            const allSuccessful = evaluatePipelineResults(results);
+            if (allSuccessful) {
+                // Mark as completed using pure function
+                this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createCompletedState(featureId, currentState));
+                logFeatureSuccess(feature.name);
+                logPipelineResults(results);
+            }
+            else {
+                // Mark as failed using pure function
+                this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
+                logFeatureFailed(feature.name);
+                logPipelineResults(results);
+                const currentState = this.processedFeatures.get(featureId);
+                logRetryInfo(feature.name, currentState.retryCount, this.options.maxRetries);
+            }
+        }
+        catch (error) {
+            // Mark as failed using pure function
+            this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
+            logFeatureError(feature.name, error);
+        }
+    }
+    /**
+     * Get current processing statistics using pure function
+     */
+    getStats() {
+        return calculateStats(this.processedFeatures, this.isRunning);
+    }
+}
+/**
+ * Create and start a workflow processor using functional composition
+ */
+export const startWorkflowProcessor = (options, config) => async () => {
+    const processor = new WorkflowProcessor(options, config);
+    await processor.start();
+    return processor;
+};
+// Re-export core functions for testing and external use
+export { createInitialState, updateFeatureState, createProcessingState, createCompletedState, createFailedState, calculateStats, } from './core/state-manager.js';
+export { shouldProcessFeature, findNextFeature } from './core/feature-filter.js';
+export { evaluatePipelineResults } from './core/pipeline-evaluator.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.41.1",
+  "version": "0.41.2",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"

package/dist/services/lifecycle-agent/__tests__/phase-criteria.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for phase quality criteria definitions
- */
-export {};