edsger 0.2.0 → 0.2.2

package/dist/types/index.d.ts

@@ -0,0 +1,112 @@
+export interface EdsgerConfig {
+    patterns: string[];
+    exclude: string[];
+    severity: 'error' | 'warning';
+    maxFiles: number;
+    claude: {
+        model?: string;
+        timeout?: number;
+    };
+}
+export interface GitFile {
+    path: string;
+    content: string;
+    status: 'modified' | 'added' | 'deleted' | 'renamed';
+}
+export interface ReviewResult {
+    file: string;
+    status: 'OK' | 'WARN' | 'BLOCK';
+    message: string;
+    details?: string;
+}
+export interface CliOptions {
+    review?: boolean;
+    staged?: boolean;
+    files?: string[];
+    config?: string;
+    verbose?: boolean;
+    featureAnalysis?: string;
+    technicalDesign?: string;
+    implement?: string;
+    test?: string;
+    workflow?: boolean;
+}
+export type ReviewSeverity = 'error' | 'warning';
+export type ExitCode = 0 | 1;
+export interface FeatureAnalysisResult {
+    featureId: string;
+    productInfo: unknown;
+    featureInfo: unknown;
+    existingUserStories: UserStory[];
+    existingTestCases: TestCase[];
+    createdUserStories: UserStory[];
+    createdTestCases: TestCase[];
+    summary: string;
+    status: 'pending' | 'success' | 'error';
+    data?: {
+        checklist_results?: Array<{
+            checklist_id: string;
+            satisfied: boolean;
+            notes?: string;
+        }>;
+        checklist_item_results?: Array<{
+            checklist_item_id: string;
+            is_passed: boolean;
+            value?: any;
+            notes?: string;
+        }>;
+    };
+}
+export interface FeatureData {
+    feature: {
+        id: string;
+        name: string;
+        description: string;
+        status: string;
+        product_id: string;
+        created_at: string;
+        updated_at: string;
+    };
+    product: {
+        id: string;
+        name: string;
+        description: string;
+        status: string;
+        features: unknown[];
+        metadata: {
+            created_at: string;
+            updated_at: string;
+        };
+    };
+}
+export interface UserStory {
+    id: string;
+    title: string;
+    description: string;
+    status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled';
+    created_at: string;
+    updated_at: string;
+}
+export interface TestCase {
+    id: string;
+    name: string;
+    description: string;
+    is_critical: boolean;
+    created_at: string;
+    updated_at: string;
+}
+export interface DisplayUserStory {
+    title: string;
+}
+export interface DisplayTestCase {
+    name: string;
+    is_critical?: boolean;
+}
+export interface FeatureAnalysisDisplayResult {
+    featureId: string;
+    status: string;
+    summary?: string;
+    createdUserStories?: DisplayUserStory[];
+    createdTestCases?: DisplayTestCase[];
+}
+export type FeatureStatus = 'backlog' | 'ready_for_dev' | 'feature_analysis' | 'technical_design' | 'code_implementation' | 'code_review' | 'ready_for_review' | 'shipped' | 'testing_in_progress' | 'testing_passed' | 'testing_failed';

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/pipeline.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Type definitions for pipeline execution
+ */
+import { EdsgerConfig } from './index.js';
+import { ChecklistPhaseContext } from '../services/checklist.js';
+export type ExecutionMode = 'full_pipeline' | 'only_feature_analysis' | 'only_technical_design' | 'only_code_implementation' | 'only_functional_testing' | 'from_feature_analysis' | 'from_technical_design' | 'from_code_implementation' | 'from_functional_testing';
+export interface PipelinePhaseOptions {
+    readonly featureId: string;
+    readonly mcpServerUrl: string;
+    readonly mcpToken: string;
+    readonly verbose?: boolean;
+}
+export interface PipelineResult {
+    readonly featureId: string;
+    readonly phase: string;
+    readonly status: 'success' | 'error';
+    readonly message: string;
+    readonly data?: unknown;
+}
+export interface PhaseConfig {
+    readonly name: string;
+    readonly checkRequirements: () => Promise<boolean>;
+    readonly execute: (options: PipelinePhaseOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<any>;
+    readonly requirementsError: string;
+}

package/dist/types/pipeline.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for pipeline execution
+ */
+export {};

package/dist/utils/logger.d.ts

@@ -0,0 +1,19 @@
+import { ReviewResult } from '../types/index.js';
+export declare const colors: {
+    reset: string;
+    bright: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    gray: string;
+};
+export declare const colorize: (text: string, color: keyof typeof colors) => string;
+export declare const logInfo: (message: string) => void;
+export declare const logSuccess: (message: string) => void;
+export declare const logWarning: (message: string) => void;
+export declare const logError: (message: string) => void;
+export declare const logProgress: (current: number, total: number, file: string) => void;
+export declare const logResults: (results: ReviewResult[], verbose?: boolean) => void;

package/dist/utils/logger.js

@@ -0,0 +1,52 @@
+export const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m'
+};
+export const colorize = (text, color) => {
+    return `${colors[color]}${text}${colors.reset}`;
+};
+export const logInfo = (message) => {
+    console.log(colorize(`ℹ ${message}`, 'blue'));
+};
+export const logSuccess = (message) => {
+    console.log(colorize(`✓ ${message}`, 'green'));
+};
+export const logWarning = (message) => {
+    console.log(colorize(`⚠ ${message}`, 'yellow'));
+};
+export const logError = (message) => {
+    console.error(colorize(`✗ ${message}`, 'red'));
+};
+export const logProgress = (current, total, file) => {
+    const percentage = Math.round((current / total) * 100);
+    const progress = `[${current}/${total}] ${percentage}%`;
+    console.log(colorize(`${progress} Reviewing ${file}`, 'gray'));
+};
+export const logResults = (results, verbose = false) => {
+    const okCount = results.filter(r => r.status === 'OK').length;
+    const warnCount = results.filter(r => r.status === 'WARN').length;
+    const blockCount = results.filter(r => r.status === 'BLOCK').length;
+    console.log('\n' + colorize('='.repeat(60), 'gray'));
+    console.log(colorize('Review Results', 'bright'));
+    console.log(colorize('='.repeat(60), 'gray'));
+    results.forEach(result => {
+        const icon = result.status === 'OK' ? '✓' : result.status === 'WARN' ? '⚠' : '✗';
+        const color = result.status === 'OK' ? 'green' : result.status === 'WARN' ? 'yellow' : 'red';
+        console.log(colorize(`${icon} ${result.file}: ${result.message}`, color));
+        if (verbose && result.details && result.status !== 'OK') {
+            console.log(colorize(`   Details: ${result.details}`, 'gray'));
+        }
+    });
+    console.log('\n' + colorize('Summary:', 'bright'));
+    console.log(colorize(`  ✓ Passed: ${okCount}`, 'green'));
+    console.log(colorize(`  ⚠ Warnings: ${warnCount}`, 'yellow'));
+    console.log(colorize(`  ✗ Blocked: ${blockCount}`, 'red'));
+    console.log(colorize(`  Total: ${results.length} files reviewed`, 'gray'));
+};

package/dist/utils/pipeline-logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Logging utilities for pipeline execution
+ */
+import { PipelineResult } from '../types/pipeline.js';
+export declare const logPipelineStart: (featureId: string, verbose?: boolean) => void;
+export declare const logPhaseResult: (result: PipelineResult, verbose?: boolean) => PipelineResult;
+export declare const logPipelineComplete: (results: readonly PipelineResult[], verbose?: boolean) => readonly PipelineResult[];
+export declare const shouldContinuePipeline: (results: readonly PipelineResult[]) => boolean;

package/dist/utils/pipeline-logger.js

@@ -0,0 +1,35 @@
+/**
+ * Logging utilities for pipeline execution
+ */
+// Pipeline execution utilities
+export const logPipelineStart = (featureId, verbose) => {
+    if (verbose) {
+        console.log(`🚀 Starting complete pipeline for feature: ${featureId}`);
+        console.log('📋 Pipeline phases: feature-analysis → technical-design → code-implementation → functional-testing');
+    }
+};
+export const logPhaseResult = (result, verbose) => {
+    if (verbose) {
+        const statusIcon = result.status === 'success' ? '✅' : '❌';
+        console.log(`${statusIcon} ${result.phase}: ${result.message}`);
+    }
+    return result;
+};
+export const logPipelineComplete = (results, verbose) => {
+    if (verbose) {
+        const lastResult = results[results.length - 1];
+        const featureId = lastResult?.featureId;
+        if (lastResult?.status === 'success') {
+            console.log(`✅ Complete pipeline finished successfully for feature: ${featureId}`);
+        }
+        else {
+            console.log(`❌ Pipeline failed at ${lastResult?.phase}: ${lastResult?.message}`);
+        }
+    }
+    return results;
+};
+// Pure function to check if pipeline should continue
+export const shouldContinuePipeline = (results) => {
+    const lastResult = results[results.length - 1];
+    return lastResult?.status === 'success';
+};

package/dist/workflow-runner/config/phase-configs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Phase configurations for the pipeline runner
+ */
+import { PhaseConfig } from '../../types/pipeline.js';
+export declare const phaseConfigs: readonly PhaseConfig[];

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

@@ -0,0 +1,34 @@
+/**
+ * Phase 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 phase configurations
+export const phaseConfigs = [
+    {
+        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/config/stage-configs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Stage configurations for the pipeline runner
+ */
+import { StageConfig } from '../../types/pipeline.js';
+export declare const stageConfigs: readonly StageConfig[];

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;