edsger 0.2.1 → 0.2.2

package/dist/workflow-runner/config/stage-configs.js

@@ -0,0 +1,34 @@
+/**
+ * Stage configurations for the pipeline runner
+ */
+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';
+// Pipeline stage configurations
+export const stageConfigs = [
+    {
+        name: 'feature-analysis',
+        checkRequirements: checkFeatureAnalysisRequirements,
+        execute: analyzeFeatureWithMCP,
+        requirementsError: 'Feature analysis requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+    {
+        name: 'technical-design',
+        checkRequirements: checkTechnicalDesignRequirements,
+        execute: generateTechnicalDesign,
+        requirementsError: 'Technical design requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+    {
+        name: 'code-implementation',
+        checkRequirements: checkCodeImplementationRequirements,
+        execute: implementFeatureCode,
+        requirementsError: 'Code implementation requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+    {
+        name: 'functional-testing',
+        checkRequirements: checkFunctionalTestingRequirements,
+        execute: runFunctionalTesting,
+        requirementsError: 'Functional testing requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+];

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

@@ -0,0 +1,16 @@
+/**
+ * Feature filtering utilities for workflow processor
+ * Pure functions for filtering and selecting features for processing
+ */
+import type { FeatureInfo } from '../../types/features.js';
+import type { FeatureProcessingState } from './state-manager.js';
+export declare const shouldProcessFeature: (maxRetries: number) => (feature: FeatureInfo, states: Map<string, FeatureProcessingState>) => boolean;
+export declare const findNextFeature: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>, maxRetries: number) => FeatureInfo | undefined;
+export declare const isFeatureProcessing: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
+export declare const isFeatureCompleted: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
+export declare const isFeatureFailed: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
+export declare const hasReachedMaxRetries: (featureId: string, states: Map<string, FeatureProcessingState>, maxRetries: number) => boolean;
+export declare const filterProcessingFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
+export declare const filterCompletedFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
+export declare const filterFailedFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
+export declare const filterAvailableFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>, maxRetries: number) => FeatureInfo[];

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

@@ -0,0 +1,46 @@
+/**
+ * Feature filtering utilities for workflow processor
+ * Pure functions for filtering and selecting features for processing
+ */
+// Feature filtering functions (pure)
+export const shouldProcessFeature = (maxRetries) => (feature, states) => {
+    const state = states.get(feature.id);
+    // If never processed, should process
+    if (!state)
+        return true;
+    // If feature was updated after last processing attempt, should reprocess
+    // This handles cases where user manually changes status back to ready_for_dev
+    if (feature.updated_at) {
+        const featureUpdatedTime = new Date(feature.updated_at).getTime();
+        const lastAttemptTime = state.lastAttempt.getTime();
+        if (featureUpdatedTime > lastAttemptTime) {
+            // Feature has been updated since last processing, reprocess it
+            return true;
+        }
+    }
+    // If failed and haven't exceeded retry limit, should retry
+    return state.status === 'failed' && state.retryCount < maxRetries;
+};
+export const findNextFeature = (features, states, maxRetries) => features.find((feature) => shouldProcessFeature(maxRetries)(feature, states));
+// Feature status checking functions (pure)
+export const isFeatureProcessing = (featureId, states) => {
+    const state = states.get(featureId);
+    return state?.status === 'processing';
+};
+export const isFeatureCompleted = (featureId, states) => {
+    const state = states.get(featureId);
+    return state?.status === 'completed';
+};
+export const isFeatureFailed = (featureId, states) => {
+    const state = states.get(featureId);
+    return state?.status === 'failed';
+};
+export const hasReachedMaxRetries = (featureId, states, maxRetries) => {
+    const state = states.get(featureId);
+    return state ? state.retryCount >= maxRetries : false;
+};
+// Feature collection filtering functions (pure)
+export const filterProcessingFeatures = (features, states) => features.filter((feature) => isFeatureProcessing(feature.id, states));
+export const filterCompletedFeatures = (features, states) => features.filter((feature) => isFeatureCompleted(feature.id, states));
+export const filterFailedFeatures = (features, states) => features.filter((feature) => isFeatureFailed(feature.id, states));
+export const filterAvailableFeatures = (features, states, maxRetries) => features.filter((feature) => shouldProcessFeature(maxRetries)(feature, states));

package/dist/workflow-runner/core/feature-filter.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for feature filtering with timestamp-based reprocessing
+ */
+export {};

package/dist/workflow-runner/core/feature-filter.test.js

@@ -0,0 +1,127 @@
+/**
+ * Unit tests for feature filtering with timestamp-based reprocessing
+ */
+import { shouldProcessFeature } from './feature-filter.js';
+describe('shouldProcessFeature with timestamp checking', () => {
+    const maxRetries = 3;
+    it('should process feature that has never been processed', () => {
+        const feature = {
+            id: 'feature-1',
+            name: 'Test Feature',
+            status: 'ready_for_dev',
+            product_id: 'product-1',
+            updated_at: '2024-01-01T10:00:00Z',
+        };
+        const states = new Map();
+        const result = shouldProcessFeature(maxRetries)(feature, states);
+        expect(result).toBe(true);
+    });
+    it('should reprocess completed feature if updated after last attempt', () => {
+        const feature = {
+            id: 'feature-1',
+            name: 'Test Feature',
+            status: 'ready_for_dev',
+            product_id: 'product-1',
+            updated_at: '2024-01-01T12:00:00Z', // Updated at noon
+        };
+        const states = new Map();
+        states.set('feature-1', {
+            featureId: 'feature-1',
+            retryCount: 1,
+            lastAttempt: new Date('2024-01-01T10:00:00Z'), // Processed at 10 AM
+            status: 'completed',
+        });
+        const result = shouldProcessFeature(maxRetries)(feature, states);
+        expect(result).toBe(true); // Should reprocess because updated after last attempt
+    });
+    it('should not reprocess completed feature if not updated after last attempt', () => {
+        const feature = {
+            id: 'feature-1',
+            name: 'Test Feature',
+            status: 'ready_for_dev',
+            product_id: 'product-1',
+            updated_at: '2024-01-01T10:00:00Z', // Updated at 10 AM
+        };
+        const states = new Map();
+        states.set('feature-1', {
+            featureId: 'feature-1',
+            retryCount: 1,
+            lastAttempt: new Date('2024-01-01T12:00:00Z'), // Processed at noon
+            status: 'completed',
+        });
+        const result = shouldProcessFeature(maxRetries)(feature, states);
+        expect(result).toBe(false); // Should not reprocess because not updated after last attempt
+    });
+    it('should reprocess failed feature if updated after last attempt', () => {
+        const feature = {
+            id: 'feature-1',
+            name: 'Test Feature',
+            status: 'ready_for_dev',
+            product_id: 'product-1',
+            updated_at: '2024-01-01T12:00:00Z', // Updated at noon
+        };
+        const states = new Map();
+        states.set('feature-1', {
+            featureId: 'feature-1',
+            retryCount: 2,
+            lastAttempt: new Date('2024-01-01T10:00:00Z'), // Failed at 10 AM
+            status: 'failed',
+        });
+        const result = shouldProcessFeature(maxRetries)(feature, states);
+        expect(result).toBe(true); // Should reprocess because updated after last attempt
+    });
+    it('should reprocess failed feature within retry limit even without update', () => {
+        const feature = {
+            id: 'feature-1',
+            name: 'Test Feature',
+            status: 'ready_for_dev',
+            product_id: 'product-1',
+            updated_at: '2024-01-01T09:00:00Z', // Not updated
+        };
+        const states = new Map();
+        states.set('feature-1', {
+            featureId: 'feature-1',
+            retryCount: 2, // Less than maxRetries (3)
+            lastAttempt: new Date('2024-01-01T10:00:00Z'),
+            status: 'failed',
+        });
+        const result = shouldProcessFeature(maxRetries)(feature, states);
+        expect(result).toBe(true); // Should retry because within retry limit
+    });
+    it('should not reprocess failed feature beyond retry limit without update', () => {
+        const feature = {
+            id: 'feature-1',
+            name: 'Test Feature',
+            status: 'ready_for_dev',
+            product_id: 'product-1',
+            updated_at: '2024-01-01T09:00:00Z', // Not updated
+        };
+        const states = new Map();
+        states.set('feature-1', {
+            featureId: 'feature-1',
+            retryCount: 3, // Equal to maxRetries
+            lastAttempt: new Date('2024-01-01T10:00:00Z'),
+            status: 'failed',
+        });
+        const result = shouldProcessFeature(maxRetries)(feature, states);
+        expect(result).toBe(false); // Should not retry because exceeded retry limit
+    });
+    it('should handle feature without updated_at timestamp', () => {
+        const feature = {
+            id: 'feature-1',
+            name: 'Test Feature',
+            status: 'ready_for_dev',
+            product_id: 'product-1',
+            // No updated_at field
+        };
+        const states = new Map();
+        states.set('feature-1', {
+            featureId: 'feature-1',
+            retryCount: 1,
+            lastAttempt: new Date('2024-01-01T10:00:00Z'),
+            status: 'completed',
+        });
+        const result = shouldProcessFeature(maxRetries)(feature, states);
+        expect(result).toBe(false); // Should not reprocess without timestamp info
+    });
+});

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

@@ -0,0 +1,8 @@
+/**
+ * Core workflow processor modules
+ * Centralized exports for all core functionality
+ */
+export * from './state-manager.js';
+export * from './feature-filter.js';
+export * from './pipeline-evaluator.js';
+export * from './workflow-logger.js';

package/dist/workflow-runner/core/index.js

@@ -0,0 +1,12 @@
+/**
+ * Core workflow processor modules
+ * Centralized exports for all core functionality
+ */
+// State management
+export * from './state-manager.js';
+// Feature filtering
+export * from './feature-filter.js';
+// Pipeline evaluation
+export * from './pipeline-evaluator.js';
+// Workflow logging
+export * from './workflow-logger.js';

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

@@ -0,0 +1,24 @@
+/**
+ * Pipeline result evaluation utilities for workflow processor
+ * Pure functions for evaluating pipeline execution results
+ */
+import type { PipelineResult } from '../../types/pipeline.js';
+export declare const evaluatePipelineResults: (results: readonly PipelineResult[]) => boolean;
+export declare const hasAnyPipelineFailures: (results: readonly PipelineResult[]) => boolean;
+export declare const countSuccessfulPhases: (results: readonly PipelineResult[]) => number;
+export declare const countFailedPhases: (results: readonly PipelineResult[]) => number;
+export declare const getFailedPhases: (results: readonly PipelineResult[]) => PipelineResult[];
+export declare const getSuccessfulPhases: (results: readonly PipelineResult[]) => PipelineResult[];
+export declare const getFirstFailure: (results: readonly PipelineResult[]) => PipelineResult | undefined;
+export declare const getLastPhaseResult: (results: readonly PipelineResult[]) => PipelineResult | undefined;
+export declare const isPipelineFullySuccessful: (results: readonly PipelineResult[]) => boolean;
+export declare const isPipelinePartiallySuccessful: (results: readonly PipelineResult[]) => boolean;
+export declare const isPipelineCompleteFailure: (results: readonly PipelineResult[]) => boolean;
+export declare const isPipelineEmpty: (results: readonly PipelineResult[]) => boolean;
+export interface PipelineStats {
+    readonly total: number;
+    readonly successful: number;
+    readonly failed: number;
+    readonly successRate: number;
+}
+export declare const calculatePipelineStats: (results: readonly PipelineResult[]) => PipelineStats;

package/dist/workflow-runner/core/pipeline-evaluator.js

@@ -0,0 +1,32 @@
+/**
+ * Pipeline result evaluation utilities for workflow processor
+ * Pure functions for evaluating pipeline execution results
+ */
+// Pipeline result evaluation (pure)
+export const evaluatePipelineResults = (results) => results.every((result) => result.status === 'success');
+export const hasAnyPipelineFailures = (results) => results.some((result) => result.status !== 'success');
+export const countSuccessfulPhases = (results) => results.filter((result) => result.status === 'success').length;
+export const countFailedPhases = (results) => results.filter((result) => result.status !== 'success').length;
+export const getFailedPhases = (results) => results.filter((result) => result.status !== 'success');
+export const getSuccessfulPhases = (results) => results.filter((result) => result.status === 'success');
+export const getFirstFailure = (results) => results.find((result) => result.status !== 'success');
+export const getLastPhaseResult = (results) => results.length > 0 ? results[results.length - 1] : undefined;
+// Pipeline completion status
+export const isPipelineFullySuccessful = (results) => results.length > 0 && evaluatePipelineResults(results);
+export const isPipelinePartiallySuccessful = (results) => results.length > 0 &&
+    countSuccessfulPhases(results) > 0 &&
+    hasAnyPipelineFailures(results);
+export const isPipelineCompleteFailure = (results) => results.length > 0 && countSuccessfulPhases(results) === 0;
+export const isPipelineEmpty = (results) => results.length === 0;
+export const calculatePipelineStats = (results) => {
+    const total = results.length;
+    const successful = countSuccessfulPhases(results);
+    const failed = countFailedPhases(results);
+    const successRate = total > 0 ? successful / total : 0;
+    return {
+        total,
+        successful,
+        failed,
+        successRate,
+    };
+};

package/dist/workflow-runner/core/state-manager.d.ts

@@ -0,0 +1,24 @@
+/**
+ * State management utilities for workflow processor
+ * Pure functions for handling feature processing states
+ */
+export interface FeatureProcessingState {
+    readonly featureId: string;
+    readonly retryCount: number;
+    readonly lastAttempt: Date;
+    readonly status: 'processing' | 'completed' | 'failed';
+    readonly featureUpdatedAt?: string;
+}
+export interface WorkflowStats {
+    readonly totalProcessed: number;
+    readonly completed: number;
+    readonly failed: number;
+    readonly processing: number;
+    readonly isRunning: boolean;
+}
+export declare const createInitialState: () => Map<string, FeatureProcessingState>;
+export declare const createProcessingState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
+export declare const createCompletedState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
+export declare const createFailedState: (featureId: string, currentState?: FeatureProcessingState) => FeatureProcessingState;
+export declare const updateFeatureState: (states: Map<string, FeatureProcessingState>, featureId: string, updateFn: (currentState?: FeatureProcessingState) => FeatureProcessingState) => Map<string, FeatureProcessingState>;
+export declare const calculateStats: (states: Map<string, FeatureProcessingState>, isRunning: boolean) => WorkflowStats;

package/dist/workflow-runner/core/state-manager.js

@@ -0,0 +1,42 @@
+/**
+ * State management utilities for workflow processor
+ * Pure functions for handling feature processing states
+ */
+// State creation functions (pure)
+export const createInitialState = () => new Map();
+export const createProcessingState = (featureId, currentState) => ({
+    featureId,
+    retryCount: currentState ? currentState.retryCount + 1 : 1,
+    lastAttempt: new Date(),
+    status: 'processing',
+});
+export const createCompletedState = (featureId, currentState) => ({
+    featureId,
+    retryCount: currentState ? currentState.retryCount : 1,
+    lastAttempt: new Date(),
+    status: 'completed',
+});
+export const createFailedState = (featureId, currentState) => ({
+    featureId,
+    retryCount: currentState ? currentState.retryCount : 1,
+    lastAttempt: new Date(),
+    status: 'failed',
+});
+// State update function (pure)
+export const updateFeatureState = (states, featureId, updateFn) => {
+    const newStates = new Map(states);
+    const currentState = newStates.get(featureId);
+    newStates.set(featureId, updateFn(currentState));
+    return newStates;
+};
+// Statistics calculation (pure)
+export const calculateStats = (states, isRunning) => {
+    const stateArray = Array.from(states.values());
+    return {
+        totalProcessed: stateArray.length,
+        completed: stateArray.filter((s) => s.status === 'completed').length,
+        failed: stateArray.filter((s) => s.status === 'failed').length,
+        processing: stateArray.filter((s) => s.status === 'processing').length,
+        isRunning,
+    };
+};

package/dist/workflow-runner/core/workflow-logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Logging utilities for workflow processor
+ * Centralized logging functions for workflow operations
+ */
+import type { FeatureInfo } from '../../types/features.js';
+import type { PipelineResult } from '../../types/pipeline.js';
+export declare const logProcessingStart: (feature: FeatureInfo, verbose?: boolean) => void;
+export declare const logRetryInfo: (featureName: string, retryCount: number, maxRetries: number) => void;
+export declare const logPipelineResults: (results: readonly PipelineResult[]) => void;
+export declare const logProcessorStart: (productId: string, pollInterval: number) => void;
+export declare const logProcessorReady: () => void;
+export declare const logProcessorStop: () => void;
+export declare const logFeatureSuccess: (featureName: string) => void;
+export declare const logFeatureFailed: (featureName: string) => void;
+export declare const logFeatureError: (featureName: string, error: unknown) => void;
+export declare const logNoFeaturesFound: () => void;
+export declare const logAllFeaturesProcessed: () => void;
+export declare const logSkippingProcessing: (processingCount: number) => void;
+export declare const logPollingError: (error: unknown) => void;
+export declare const logProcessNextFeatureError: (error: unknown) => void;

package/dist/workflow-runner/core/workflow-logger.js

@@ -0,0 +1,65 @@
+/**
+ * Logging utilities for workflow processor
+ * Centralized logging functions for workflow operations
+ */
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+export const logProcessingStart = (feature, verbose) => {
+    logInfo(`🎯 Processing feature: ${feature.name} (${feature.id})`);
+    if (verbose) {
+        logInfo(`   Description: ${feature.description}`);
+        logInfo(`   Last updated: ${feature.updated_at}`);
+    }
+};
+export const logRetryInfo = (featureName, retryCount, maxRetries) => {
+    if (retryCount < maxRetries) {
+        logInfo(`🔄 Will retry feature ${featureName} (attempt ${retryCount + 1}/${maxRetries})`);
+    }
+    else {
+        logError(`⛔ Max retries reached for feature ${featureName}, marking as permanently failed`);
+    }
+};
+export const 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.phase}: ${result.message}`);
+    });
+    console.log('='.repeat(60) + '\n');
+};
+export const logProcessorStart = (productId, pollInterval) => {
+    logInfo('🚀 Starting workflow processor...');
+    logInfo(`📋 Product ID: ${productId}`);
+    logInfo(`🔄 Poll interval: ${pollInterval}ms`);
+};
+export const logProcessorReady = () => {
+    logInfo('✅ Workflow processor started and monitoring for new features');
+};
+export const logProcessorStop = () => {
+    logInfo('⏹️  Workflow processor stopped');
+};
+export const logFeatureSuccess = (featureName) => {
+    logSuccess(`✅ Feature ${featureName} completed successfully!`);
+};
+export const logFeatureFailed = (featureName) => {
+    logError(`❌ Feature ${featureName} failed in pipeline`);
+};
+export const logFeatureError = (featureName, error) => {
+    logError(`❌ Error processing feature ${featureName}: ${error instanceof Error ? error.message : String(error)}`);
+};
+export const logNoFeaturesFound = () => {
+    logInfo('🔍 No ready_for_dev features found, continuing to monitor...');
+};
+export const logAllFeaturesProcessed = () => {
+    logInfo('🔄 All current features are processed or being processed, continuing to monitor...');
+};
+export const logSkippingProcessing = (processingCount) => {
+    logInfo(`⏳ Skipping feature fetching as ${processingCount} feature(s) are currently being processed`);
+};
+export const logPollingError = (error) => {
+    logError(`Error in polling cycle: ${error instanceof Error ? error.message : String(error)}`);
+};
+export const logProcessNextFeatureError = (error) => {
+    logError(`Error in processNextFeature: ${error instanceof Error ? error.message : String(error)}`);
+};

package/dist/workflow-runner/executors/phase-executor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Phase execution logic for pipeline runner
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { PipelinePhaseOptions, PipelineResult, PhaseConfig } from '../../types/pipeline.js';
+export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, };