edsger 0.2.1 → 0.2.2

package/dist/workflow-runner/pipeline.js

@@ -0,0 +1,197 @@
+/**
+ * Pipeline execution logic for feature development workflow
+ */
+import { updateFeatureStatusForStage } from './feature-service.js';
+// Import phase analyzers
+import { analyzeFeatureWithMCP, checkFeatureAnalysisRequirements, } from '../phases/feature-analysis/analyzer.js';
+import { generateTechnicalDesign, checkTechnicalDesignRequirements, } from '../phases/technical-design/analyzer.js';
+import { implementFeatureCode, checkCodeImplementationRequirements, } from '../phases/code-implementation/analyzer.js';
+import { runFunctionalTesting, checkFunctionalTestingRequirements, } from '../phases/functional-testing/analyzer.js';
+import { fixTestFailures, checkBugFixingRequirements, } from '../phases/bug-fixing/analyzer.js';
+import { createPullRequest, updateFeatureWithPullRequest, } from '../phases/pull-request/creator.js';
+import { getFeature } from '../api/features.js';
+// Common requirements error message
+const COMMON_REQUIREMENTS_ERROR = 'Requirements not met. Install with: npm install @anthropic-ai/claude-code zod';
+// Pipeline stage configurations
+const stageConfigs = [
+    {
+        name: 'feature-analysis',
+        checkRequirements: checkFeatureAnalysisRequirements,
+        execute: analyzeFeatureWithMCP,
+        requirementsError: `Feature analysis ${COMMON_REQUIREMENTS_ERROR}`,
+    },
+    {
+        name: 'technical-design',
+        checkRequirements: checkTechnicalDesignRequirements,
+        execute: generateTechnicalDesign,
+        requirementsError: `Technical design ${COMMON_REQUIREMENTS_ERROR}`,
+    },
+    {
+        name: 'code-implementation',
+        checkRequirements: checkCodeImplementationRequirements,
+        execute: implementFeatureCode,
+        requirementsError: `Code implementation ${COMMON_REQUIREMENTS_ERROR}`,
+    },
+    {
+        name: 'functional-testing',
+        checkRequirements: checkFunctionalTestingRequirements,
+        execute: runFunctionalTesting,
+        requirementsError: `Functional testing ${COMMON_REQUIREMENTS_ERROR}`,
+    },
+];
+/**
+ * Execute a single pipeline stage
+ */
+async function executeStage(stageConfig, options, config) {
+    const { featureId } = options;
+    try {
+        // Check requirements
+        if (!(await stageConfig.checkRequirements())) {
+            return {
+                featureId,
+                stage: stageConfig.name,
+                status: 'error',
+                message: stageConfig.requirementsError,
+            };
+        }
+        // Update status to indicate stage is starting
+        await updateFeatureStatusForStage(options.mcpServerUrl, options.mcpToken, featureId, stageConfig.name, options.verbose);
+        // Execute stage
+        const result = await stageConfig.execute(options, config);
+        return {
+            featureId,
+            stage: stageConfig.name,
+            status: 'success',
+            message: `${stageConfig.name} completed successfully`,
+            data: result,
+        };
+    }
+    catch (error) {
+        return {
+            featureId,
+            stage: stageConfig.name,
+            status: 'error',
+            message: `${stageConfig.name} failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/**
+ * Run the complete pipeline for a feature
+ */
+export async function runCompletePipeline(options, config, githubConfig) {
+    const results = [];
+    for (const stageConfig of stageConfigs) {
+        const result = await executeStage(stageConfig, options, config);
+        results.push(result);
+        // Stop pipeline if stage failed
+        if (result.status === 'error') {
+            break;
+        }
+    }
+    // Handle testing failures with bug fixing
+    const lastResult = results[results.length - 1];
+    if (lastResult?.stage === 'functional-testing' &&
+        lastResult?.status === 'error') {
+        // Try bug fixing
+        try {
+            if (await checkBugFixingRequirements()) {
+                await updateFeatureStatusForStage(options.mcpServerUrl, options.mcpToken, options.featureId, 'bug-fixing', options.verbose);
+                const bugFixResult = await fixTestFailures({
+                    ...options,
+                    testErrors: 'Functional testing failed',
+                }, config);
+                results.push({
+                    featureId: options.featureId,
+                    stage: 'bug-fixing',
+                    status: 'success',
+                    message: 'Bug fixing completed',
+                    data: bugFixResult,
+                });
+                // Retry functional testing
+                const functionalTestingStage = stageConfigs.find(stage => stage.name === 'functional-testing');
+                if (!functionalTestingStage) {
+                    throw new Error('Functional testing stage configuration not found');
+                }
+                const retestResult = await executeStage(functionalTestingStage, options, config);
+                results.push(retestResult);
+            }
+        }
+        catch (error) {
+            results.push({
+                featureId: options.featureId,
+                stage: 'bug-fixing',
+                status: 'error',
+                message: `Bug fixing failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+    }
+    // Create pull request if GitHub configuration is provided and all stages succeeded
+    const allSuccessful = results.every((r) => r.status === 'success');
+    if (githubConfig && allSuccessful) {
+        try {
+            // Get feature details for PR creation
+            const feature = await getFeature(options.mcpServerUrl, options.mcpToken, options.featureId, options.verbose);
+            if (feature) {
+                const prConfig = {
+                    githubToken: githubConfig.githubToken,
+                    owner: githubConfig.githubOwner,
+                    repo: githubConfig.githubRepo,
+                    baseBranch: githubConfig.githubBaseBranch || 'main',
+                    verbose: options.verbose,
+                };
+                // Convert API FeatureInfo to PR FeatureInfo format
+                const prFeature = {
+                    id: feature.id,
+                    name: feature.name,
+                    description: feature.description || 'No description provided',
+                    productId: feature.product_id,
+                    technicalDesign: feature.technical_design,
+                    testResult: undefined,
+                    testReportUrl: undefined,
+                };
+                const prResult = await createPullRequest(prConfig, prFeature);
+                if (prResult.success && prResult.pullRequestUrl) {
+                    // Update feature with PR URL
+                    await updateFeatureWithPullRequest(options.mcpServerUrl, options.mcpToken, options.featureId, prResult.pullRequestUrl, options.verbose);
+                    results.push({
+                        featureId: options.featureId,
+                        stage: 'pull-request',
+                        status: 'success',
+                        message: `Pull request created: ${prResult.pullRequestUrl}`,
+                        data: prResult,
+                    });
+                }
+                else {
+                    results.push({
+                        featureId: options.featureId,
+                        stage: 'pull-request',
+                        status: 'error',
+                        message: `Pull request creation failed: ${prResult.error || 'Unknown error'}`,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            results.push({
+                featureId: options.featureId,
+                stage: 'pull-request',
+                status: 'error',
+                message: `Pull request creation failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Log pipeline results summary
+ */
+export function logPipelineResults(results) {
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 Pipeline Results Summary');
+    console.log('='.repeat(60));
+    results.forEach((result, index) => {
+        const statusIcon = result.status === 'success' ? '✅' : '❌';
+        console.log(`${index + 1}. ${statusIcon} ${result.stage}: ${result.message}`);
+    });
+    console.log('='.repeat(60) + '\n');
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Main workflow processor for continuous feature development
+ */
+import { EdsgerConfig } from '../types.js';
+import { WorkflowOptions, WorkflowStats } from './types.js';
+/**
+ * Main workflow processor class
+ */
+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
+     */
+    private processNextFeature;
+    /**
+     * Process a single feature through the complete pipeline
+     */
+    private processFeature;
+    /**
+     * Get current processing statistics
+     */
+    getStats(): WorkflowStats;
+}
+/**
+ * Create and start a workflow processor
+ */
+export declare function startWorkflowProcessor(options: WorkflowOptions, config: EdsgerConfig): Promise<WorkflowProcessor>;

package/dist/workflow-runner/processor.js

@@ -0,0 +1,191 @@
+/**
+ * Main workflow processor for continuous feature development
+ */
+import { logInfo, logError, logSuccess } from '../logger.js';
+import { fetchReadyForDevFeatures } from './feature-service.js';
+import { runCompletePipeline, logPipelineResults } from './pipeline.js';
+/**
+ * Main workflow processor class
+ */
+export class WorkflowProcessor {
+    options;
+    config;
+    isRunning = false;
+    processedFeatures = new Map();
+    pollTimer;
+    constructor(options, config) {
+        this.options = {
+            pollInterval: 30000, // 30 seconds default
+            maxRetries: 3,
+            verbose: false,
+            ...options,
+        };
+        this.config = config;
+    }
+    /**
+     * Start the workflow processor
+     */
+    async start() {
+        if (this.isRunning) {
+            logInfo('Workflow processor is already running');
+            return;
+        }
+        this.isRunning = true;
+        logInfo('🚀 Starting workflow processor...');
+        logInfo(`📋 Product ID: ${this.options.productId}`);
+        logInfo(`🔄 Poll interval: ${this.options.pollInterval}ms`);
+        // Initial check
+        await this.processNextFeature();
+        // Set up polling for new features
+        this.pollTimer = setInterval(() => {
+            this.processNextFeature().catch((error) => {
+                logError(`Error in polling cycle: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, this.options.pollInterval);
+        logInfo('✅ Workflow processor started and monitoring for new features');
+    }
+    /**
+     * Stop the workflow processor
+     */
+    stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = undefined;
+        }
+        logInfo('⏹️  Workflow processor stopped');
+    }
+    /**
+     * Process the next available feature
+     */
+    async processNextFeature() {
+        try {
+            // Skip if features are being processed
+            const processing = Array.from(this.processedFeatures.values()).filter((s) => s.status === 'processing').length;
+            if (processing > 0) {
+                if (this.options.verbose) {
+                    logInfo(`⏳ Skipping - ${processing} feature(s) being processed`);
+                }
+                return;
+            }
+            // Fetch ready features
+            const features = await fetchReadyForDevFeatures(this.options.mcpServerUrl, this.options.mcpToken, this.options.productId, this.options.verbose);
+            if (features.length === 0) {
+                if (this.options.verbose) {
+                    logInfo('🔍 No ready_for_dev features found, continuing to monitor...');
+                }
+                return;
+            }
+            // Find next feature to process
+            const nextFeature = features.find((feature) => {
+                const state = this.processedFeatures.get(feature.id);
+                return (!state ||
+                    (state.status === 'failed' &&
+                        state.retryCount < this.options.maxRetries));
+            });
+            if (!nextFeature) {
+                if (this.options.verbose) {
+                    logInfo('🔄 All features processed or being processed, continuing to monitor...');
+                }
+                return;
+            }
+            // Process the feature
+            await this.processFeature(nextFeature);
+        }
+        catch (error) {
+            logError(`Error in processNextFeature: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Process a single feature through the complete pipeline
+     */
+    async processFeature(feature) {
+        const featureId = feature.id;
+        const currentState = this.processedFeatures.get(featureId);
+        // Update state to processing
+        this.processedFeatures.set(featureId, {
+            featureId,
+            retryCount: currentState ? currentState.retryCount + 1 : 1,
+            lastAttempt: new Date(),
+            status: 'processing',
+        });
+        logInfo(`🎯 Processing feature: ${feature.name} (${feature.id})`);
+        if (this.options.verbose) {
+            logInfo(`   Description: ${feature.description}`);
+            logInfo(`   Status: ${feature.status}`);
+        }
+        try {
+            // Prepare GitHub configuration if provided
+            const githubConfig = this.options.githubToken && this.options.githubOwner && this.options.githubRepo
+                ? {
+                    githubToken: this.options.githubToken,
+                    githubOwner: this.options.githubOwner,
+                    githubRepo: this.options.githubRepo,
+                    githubBaseBranch: this.options.githubBaseBranch,
+                }
+                : undefined;
+            // Run complete pipeline
+            const results = await runCompletePipeline({
+                featureId,
+                mcpServerUrl: this.options.mcpServerUrl,
+                mcpToken: this.options.mcpToken,
+                verbose: this.options.verbose,
+            }, this.config, githubConfig);
+            // Check if all stages succeeded
+            const allSuccessful = results.every((r) => r.status === 'success');
+            if (allSuccessful) {
+                this.processedFeatures.set(featureId, {
+                    featureId,
+                    retryCount: this.processedFeatures.get(featureId).retryCount,
+                    lastAttempt: new Date(),
+                    status: 'completed',
+                });
+                logSuccess(`✅ Feature ${feature.name} completed successfully!`);
+            }
+            else {
+                this.processedFeatures.set(featureId, {
+                    featureId,
+                    retryCount: this.processedFeatures.get(featureId).retryCount,
+                    lastAttempt: new Date(),
+                    status: 'failed',
+                });
+                logError(`❌ Feature ${feature.name} failed in pipeline`);
+            }
+            // Log pipeline results
+            logPipelineResults(results);
+        }
+        catch (error) {
+            this.processedFeatures.set(featureId, {
+                featureId,
+                retryCount: this.processedFeatures.get(featureId).retryCount,
+                lastAttempt: new Date(),
+                status: 'failed',
+            });
+            logError(`❌ Error processing feature ${feature.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get current processing statistics
+     */
+    getStats() {
+        const states = Array.from(this.processedFeatures.values());
+        return {
+            totalProcessed: states.length,
+            completed: states.filter((s) => s.status === 'completed').length,
+            failed: states.filter((s) => s.status === 'failed').length,
+            processing: states.filter((s) => s.status === 'processing').length,
+            isRunning: this.isRunning,
+        };
+    }
+}
+/**
+ * Create and start a workflow processor
+ */
+export async function startWorkflowProcessor(options, config) {
+    const processor = new WorkflowProcessor(options, config);
+    await processor.start();
+    return processor;
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Types and interfaces for workflow processor
+ */
+import { EdsgerConfig } from '../types.js';
+export interface WorkflowOptions {
+    readonly productId: string;
+    readonly mcpServerUrl: string;
+    readonly mcpToken: string;
+    readonly pollInterval?: number;
+    readonly maxRetries?: number;
+    readonly verbose?: boolean;
+    readonly githubToken?: string;
+    readonly githubOwner?: string;
+    readonly githubRepo?: string;
+    readonly githubBaseBranch?: string;
+}
+export interface PipelineStageOptions {
+    readonly featureId: string;
+    readonly mcpServerUrl: string;
+    readonly mcpToken: string;
+    readonly verbose?: boolean;
+}
+export interface PipelineResult {
+    readonly featureId: string;
+    readonly stage: string;
+    readonly status: 'success' | 'error';
+    readonly message: string;
+    readonly data?: unknown;
+}
+export interface FeatureProcessingState {
+    readonly featureId: string;
+    readonly retryCount: number;
+    readonly lastAttempt: Date;
+    readonly status: 'processing' | 'completed' | 'failed';
+}
+export interface WorkflowStats {
+    readonly totalProcessed: number;
+    readonly completed: number;
+    readonly failed: number;
+    readonly processing: number;
+    readonly isRunning: boolean;
+}
+export interface StageConfig {
+    readonly name: string;
+    readonly checkRequirements: () => Promise<boolean>;
+    readonly execute: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<any>;
+    readonly requirementsError: string;
+}

package/dist/workflow-runner/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types and interfaces for workflow processor
+ */
+export {};

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

@@ -3,9 +3,8 @@
  * Monitors for ready_for_dev features and processes them through the complete pipeline
  * Uses functional programming principles
  */
-import { EdsgerConfig } from '../types.js';
-import { FeatureInfo } from './feature-fetcher.js';
-import { PipelineResult } from './pipeline-runner.js';
+import { EdsgerConfig } from '../types/index.js';
+import { type WorkflowStats } from './core/state-manager.js';
 export interface WorkflowOptions {
     readonly productId: string;
     readonly mcpServerUrl: string;
@@ -14,25 +13,7 @@ export interface WorkflowOptions {
     readonly maxRetries?: number;
     readonly verbose?: boolean;
 }
-export interface FeatureProcessingState {
-    readonly featureId: string;
-    readonly retryCount: number;
-    readonly lastAttempt: Date;
-    readonly status: 'processing' | 'completed' | 'failed';
-}
-export interface WorkflowStats {
-    readonly totalProcessed: number;
-    readonly completed: number;
-    readonly failed: number;
-    readonly processing: number;
-    readonly isRunning: boolean;
-}
-declare const createInitialState: () => Map<string, FeatureProcessingState>;
-declare const updateFeatureState: (states: Map<string, FeatureProcessingState>, featureId: string, updateFn: (currentState?: FeatureProcessingState) => FeatureProcessingState) => Map<string, FeatureProcessingState>;
-declare const shouldProcessFeature: (maxRetries: number) => (feature: FeatureInfo, states: Map<string, FeatureProcessingState>) => boolean;
-declare const findNextFeature: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>, maxRetries: number) => FeatureInfo | undefined;
-declare const evaluatePipelineResults: (results: readonly PipelineResult[]) => boolean;
-declare const calculateStats: (states: Map<string, FeatureProcessingState>, isRunning: boolean) => WorkflowStats;
+export type { FeatureProcessingState, WorkflowStats, } from './core/state-manager.js';
 /**
  * Workflow processor using functional programming principles
  */
@@ -68,4 +49,6 @@ export declare class WorkflowProcessor {
  * Create and start a workflow processor using functional composition
  */
 export declare const startWorkflowProcessor: (options: WorkflowOptions, config: EdsgerConfig) => () => Promise<WorkflowProcessor>;
-export { createInitialState, updateFeatureState, shouldProcessFeature, findNextFeature, evaluatePipelineResults, calculateStats, };
+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';