edsger 0.2.3 → 0.2.5

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

@@ -1,34 +0,0 @@
-/**
- * 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.test.d.ts

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

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

@@ -1,127 +0,0 @@
-/**
- * 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/executors/stage-executor.d.ts

@@ -1,8 +0,0 @@
-/**
- * Stage execution logic for pipeline runner
- */
-import { EdsgerConfig } from '../../types/index.js';
-import { PipelineStageOptions, PipelineResult, StageConfig } from '../../types/pipeline.js';
-export declare const createStageRunner: (stageConfig: StageConfig) => (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runFeatureAnalysisStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage, };

package/dist/workflow-runner/executors/stage-executor.js

@@ -1,49 +0,0 @@
-/**
- * Stage execution logic for pipeline runner
- */
-import { updateFeatureStatusForStage } from '../../api/features/index.js';
-import { stageConfigs } from '../config/stage-configs.js';
-// Higher-order function for stage execution
-export const createStageRunner = (stageConfig) => async (options, config) => {
-    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
-    const { name, checkRequirements, execute, requirementsError } = stageConfig;
-    try {
-        // Check requirements
-        const hasRequirements = await checkRequirements();
-        if (!hasRequirements) {
-            return {
-                featureId,
-                stage: name,
-                status: 'error',
-                message: requirementsError,
-            };
-        }
-        // Update feature status to reflect current stage
-        await updateFeatureStatusForStage({ mcpServerUrl, mcpToken }, featureId, name, verbose);
-        if (verbose) {
-            console.log(`🎯 Starting ${name} for: ${featureId}`);
-        }
-        const result = await execute(options, config);
-        return {
-            featureId,
-            stage: name,
-            status: result.status === 'success' ? 'success' : 'error',
-            message: result.status === 'success'
-                ? `${name.replace('-', ' ')} completed successfully`
-                : `${name.replace('-', ' ')} failed`,
-            data: result,
-        };
-    }
-    catch (error) {
-        return {
-            featureId,
-            stage: name,
-            status: 'error',
-            message: `${name.replace('-', ' ')} failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-};
-// Create stage runners using the configuration
-const [runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage,] = stageConfigs.map(createStageRunner);
-// Export individual stage runners for granular control
-export { runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage, };

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

@@ -1,41 +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
- */
-export interface McpClientConfig {
-    readonly mcpServerUrl: string;
-    readonly mcpToken: string;
-    readonly verbose?: boolean;
-}
-export declare const createMcpClient: (config: McpClientConfig) => {
-    call: <T>(method: string, params: unknown) => Promise<T>;
-};
-export interface FeatureInfo {
-    readonly id: string;
-    readonly name: string;
-    readonly description: string;
-    readonly status: string;
-    readonly product_id: string;
-    readonly created_at: string;
-    readonly updated_at: string;
-}
-export interface FetchFeaturesOptions {
-    readonly mcpServerUrl: string;
-    readonly mcpToken: string;
-    readonly productId: string;
-    readonly verbose?: boolean;
-}
-declare const filterFeaturesByStatus: (status: string) => (features: FeatureInfo[]) => FeatureInfo[];
-declare const sortFeaturesByUpdatedAt: (features: FeatureInfo[]) => FeatureInfo[];
-/**
- * Fetch all features with ready_for_dev status for a product, sorted by updated_at
- * Pure functional approach with composition
- */
-export declare const fetchReadyForDevFeatures: (options: FetchFeaturesOptions) => () => Promise<FeatureInfo[]>;
-/**
- * Get feature details by ID
- * Functional approach with error handling
- */
-export declare const getFeatureDetails: (featureId: string, options: Omit<FetchFeaturesOptions, "productId">) => () => Promise<FeatureInfo | null>;
-export { filterFeaturesByStatus, sortFeaturesByUpdatedAt };

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;