edsger 0.2.2 → 0.2.4

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

@@ -1,121 +0,0 @@
-/**
- * Feature fetcher module for workflow processing
- * Fetches features with ready_for_dev status and handles product queries via MCP
- * Uses functional programming principles
- */
-// Pure function to create MCP request payload
-const createMcpRequest = (method, params) => ({
-    jsonrpc: '2.0',
-    method,
-    params,
-    id: Math.random().toString(36).substring(7),
-});
-// Higher-order function to create MCP client
-export const createMcpClient = (config) => {
-    const { mcpServerUrl, mcpToken } = config;
-    return {
-        call: async (method, params) => {
-            const requestBody = createMcpRequest(method, params);
-            const response = await fetch(`${mcpServerUrl}/mcp`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${mcpToken}`,
-                },
-                body: JSON.stringify(requestBody),
-            });
-            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 || 'MCP call failed');
-            }
-            return data.result;
-        },
-    };
-};
-// Pure function to filter features by status
-const filterFeaturesByStatus = (status) => (features) => features.filter((feature) => feature.status === status);
-// Pure function to sort features by updated_at (most recent first)
-const sortFeaturesByUpdatedAt = (features) => [...features].sort((a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime());
-// Curried logging function
-const logFeatureResults = (verbose) => (features) => {
-    if (verbose) {
-        console.log(`✅ Found ${features.length} ready_for_dev features`);
-        features.forEach((feature, index) => {
-            console.log(`   ${index + 1}. ${feature.name} (updated: ${feature.updated_at})`);
-        });
-    }
-    return features;
-};
-// Composition helpers
-const pipe = (...fns) => (value) => fns.reduce((acc, fn) => fn(acc), value);
-const tap = (fn) => (value) => {
-    fn(value);
-    return value;
-};
-/**
- * Fetch all features with ready_for_dev status for a product, sorted by updated_at
- * Pure functional approach with composition
- */
-export const fetchReadyForDevFeatures = (options) => {
-    const { mcpServerUrl, mcpToken, productId, verbose } = options;
-    const client = createMcpClient({ mcpServerUrl, mcpToken, verbose });
-    const logStart = () => {
-        if (verbose) {
-            console.log(`📋 Fetching ready_for_dev features for product: ${productId}`);
-        }
-    };
-    const logMcpResponse = (result) => {
-        if (verbose) {
-            console.log(`📊 MCP server response:`, result);
-        }
-        return result;
-    };
-    const extractFeatures = (result) => result?.features || [];
-    const processFeatures = logFeatureResults(verbose || false);
-    return async () => {
-        try {
-            logStart();
-            const result = await client.call('features/list', {
-                product_id: productId,
-                status: 'ready_for_dev',
-            });
-            const mcpLogged = tap(logMcpResponse)(result);
-            const features = extractFeatures(mcpLogged);
-            return processFeatures(features);
-        }
-        catch (error) {
-            console.error(`❌ Error fetching features:`, error);
-            throw error;
-        }
-    };
-};
-/**
- * Get feature details by ID
- * Functional approach with error handling
- */
-export const getFeatureDetails = (featureId, options) => {
-    const { mcpServerUrl, mcpToken, verbose } = options;
-    const client = createMcpClient({ mcpServerUrl, mcpToken, verbose });
-    const logStart = () => {
-        if (verbose) {
-            console.log(`🔍 Getting details for feature: ${featureId}`);
-        }
-    };
-    const extractFeature = (result) => result?.features?.[0] || null;
-    return async () => {
-        try {
-            logStart();
-            const result = await client.call('features/get', { feature_id: featureId });
-            return extractFeature(result);
-        }
-        catch (error) {
-            console.error(`❌ Error getting feature details:`, error);
-            return null;
-        }
-    };
-};
-// Export utility functions for composition
-export { filterFeaturesByStatus, sortFeaturesByUpdatedAt };

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

@@ -1,17 +0,0 @@
-/**
- * Feature fetching and status management service
- */
-import { FeatureStatus } from '../types.js';
-import { type FeatureInfo } from '../api/features.js';
-/**
- * Fetch features with ready_for_dev status for a product
- */
-export declare function fetchReadyForDevFeatures(mcpServerUrl: string, mcpToken: string, productId: string, verbose?: boolean): Promise<FeatureInfo[]>;
-/**
- * Map pipeline stage to feature status
- */
-export declare function getStatusForStage(stage: string): FeatureStatus;
-/**
- * Update feature status based on pipeline stage
- */
-export declare function updateFeatureStatusForStage(mcpServerUrl: string, mcpToken: string, featureId: string, stage: string, verbose?: boolean): Promise<boolean>;

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

@@ -1,60 +0,0 @@
-/**
- * Feature fetching and status management service
- */
-import { logInfo, logError } from '../logger.js';
-import { updateFeatureStatus, } from '../api/features.js';
-import { callMcpEndpoint } from '../api/mcp-client.js';
-/**
- * Fetch features with ready_for_dev status for a product
- */
-export async function fetchReadyForDevFeatures(mcpServerUrl, mcpToken, productId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`📋 Fetching ready_for_dev features for product: ${productId}`);
-        }
-        const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/list', {
-            product_id: productId,
-            status: 'ready_for_dev',
-        }));
-        const features = result?.features || [];
-        if (verbose) {
-            logInfo(`✅ Found ${features.length} ready_for_dev features`);
-            features.forEach((feature, index) => {
-                logInfo(`   ${index + 1}. ${feature.name} (${feature.id})`);
-            });
-        }
-        return features;
-    }
-    catch (error) {
-        logError(`❌ Error fetching features: ${error}`);
-        throw error;
-    }
-}
-/**
- * Map pipeline stage to feature status
- */
-export function 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 async function updateFeatureStatusForStage(mcpServerUrl, mcpToken, featureId, stage, verbose) {
-    const status = getStatusForStage(stage);
-    return await updateFeatureStatus(mcpServerUrl, mcpToken, featureId, status, verbose);
-}

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

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

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 {};