edsger 0.41.1 → 0.41.2

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

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

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

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

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

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

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

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

package/dist/workflow-runner/index.js

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

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

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