edsger 0.2.3 → 0.2.4

package/dist/workflow-runner/pipeline.js

@@ -1,197 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-/**
- * 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

@@ -1,191 +0,0 @@
-/**
- * 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/status-updater.d.ts

@@ -1,27 +0,0 @@
-/**
- * Feature status updater for workflow pipeline
- * Updates feature status at each stage of the development workflow
- */
-import type { FeatureStatus } from '../types.js';
-interface McpClientConfig {
-    readonly mcpServerUrl: string;
-    readonly mcpToken: string;
-}
-interface StatusUpdateOptions extends McpClientConfig {
-    readonly featureId: string;
-    readonly status: FeatureStatus;
-    readonly verbose?: boolean;
-}
-/**
- * Update feature status via MCP endpoint
- */
-export declare function updateFeatureStatus({ mcpServerUrl, mcpToken, featureId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
-/**
- * Map pipeline stage to feature status
- */
-export declare const getStatusForStage: (stage: string) => FeatureStatus;
-/**
- * Update feature status based on pipeline stage
- */
-export declare const updateFeatureStatusForStage: (mcpConfig: McpClientConfig, featureId: string, stage: string, verbose?: boolean) => Promise<boolean>;
-export {};

package/dist/workflow-runner/status-updater.js

@@ -1,80 +0,0 @@
-/**
- * Feature status updater for workflow pipeline
- * Updates feature status at each stage of the development workflow
- */
-/**
- * Update feature status via MCP endpoint
- */
-export async function updateFeatureStatus({ mcpServerUrl, mcpToken, featureId, status, verbose = false, }) {
-    try {
-        if (verbose) {
-            console.log(`📊 Updating feature ${featureId} status to: ${status}`);
-        }
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method: 'features/update',
-                params: {
-                    feature_id: featureId,
-                    status,
-                },
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'Status update failed');
-        }
-        if (verbose) {
-            console.log(`✅ Feature status updated successfully to: ${status}`);
-        }
-        return true;
-    }
-    catch (error) {
-        if (verbose) {
-            console.error(`❌ Failed to update feature status: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return false;
-    }
-}
-/**
- * Map pipeline stage to feature status
- */
-export const getStatusForStage = (stage) => {
-    switch (stage) {
-        case 'feature-analysis':
-            return 'feature_analysis';
-        case 'technical-design':
-            return 'technical_design';
-        case 'code-implementation':
-            return 'code_implementation';
-        case 'functional-testing':
-            return 'testing_in_progress';
-        case 'testing-passed':
-            return 'testing_passed';
-        case 'testing-failed':
-            return 'testing_failed';
-        default:
-            return 'backlog';
-    }
-};
-/**
- * Update feature status based on pipeline stage
- */
-export const updateFeatureStatusForStage = (mcpConfig, featureId, stage, verbose) => {
-    const status = getStatusForStage(stage);
-    return updateFeatureStatus({
-        ...mcpConfig,
-        featureId,
-        status,
-        verbose,
-    });
-};

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

@@ -1,48 +0,0 @@
-/**
- * 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

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