edsger 0.2.0 → 0.2.2

package/dist/workflow-runner/workflow-processor.js

@@ -3,80 +3,14 @@
  * Monitors for ready_for_dev features and processes them through the complete pipeline
  * Uses functional programming principles
  */
-import { logInfo, logError, logSuccess } from '../logger.js';
-import { fetchReadyForDevFeatures } from './feature-fetcher.js';
-import { runCompletePipeline } from './pipeline-runner.js';
-// State management functions (pure functions)
-const createInitialState = () => new Map();
-const updateFeatureState = (states, featureId, updateFn) => {
-    const newStates = new Map(states);
-    const currentState = newStates.get(featureId);
-    newStates.set(featureId, updateFn(currentState));
-    return newStates;
-};
-const createProcessingState = (featureId, currentState) => ({
-    featureId,
-    retryCount: currentState ? currentState.retryCount + 1 : 1,
-    lastAttempt: new Date(),
-    status: 'processing',
-});
-const createCompletedState = (featureId, currentState) => ({
-    featureId,
-    retryCount: currentState ? currentState.retryCount : 1,
-    lastAttempt: new Date(),
-    status: 'completed',
-});
-const createFailedState = (featureId, currentState) => ({
-    featureId,
-    retryCount: currentState ? currentState.retryCount : 1,
-    lastAttempt: new Date(),
-    status: 'failed',
-});
-// Feature filtering functions (pure)
-const shouldProcessFeature = (maxRetries) => (feature, states) => {
-    const state = states.get(feature.id);
-    return (!state || (state.status === 'failed' && state.retryCount < maxRetries));
-};
-const findNextFeature = (features, states, maxRetries) => features.find((feature) => shouldProcessFeature(maxRetries)(feature, states));
-// Pipeline result evaluation (pure)
-const evaluatePipelineResults = (results) => results.every((result) => result.status === 'success');
-// Logging functions (side effects contained)
-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.stage}: ${result.message}`);
-    });
-    console.log('='.repeat(60) + '\\n');
-};
-const logProcessingStart = (feature, verbose) => {
-    logInfo(`🎯 Processing feature: ${feature.name} (${feature.id})`);
-    if (verbose) {
-        logInfo(`   Description: ${feature.description}`);
-        logInfo(`   Last updated: ${feature.updated_at}`);
-    }
-};
-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`);
-    }
-};
-// Statistics calculation (pure)
-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,
-    };
-};
+import { getReadyForDevFeatures } from '../api/features/index.js';
+import { runFeatureWorkflow } from './feature-workflow-runner.js';
+import { logInfo } from '../utils/logger.js';
+// Import core modules
+import { createInitialState, updateFeatureState, createProcessingState, createCompletedState, createFailedState, calculateStats, } from './core/state-manager.js';
+import { findNextFeature } from './core/feature-filter.js';
+import { evaluatePipelineResults } from './core/pipeline-evaluator.js';
+import { logProcessingStart, logRetryInfo, logPipelineResults, logProcessorStart, logProcessorReady, logProcessorStop, logFeatureSuccess, logFeatureFailed, logFeatureError, logNoFeaturesFound, logAllFeaturesProcessed, logSkippingProcessing, logPollingError, logProcessNextFeatureError, } from './core/workflow-logger.js';
 /**
  * Workflow processor using functional programming principles
  */
@@ -104,18 +38,16 @@ export class WorkflowProcessor {
             return;
         }
         this.isRunning = true;
-        logInfo('🚀 Starting workflow processor...');
-        logInfo(`📋 Product ID: ${this.options.productId}`);
-        logInfo(`🔄 Poll interval: ${this.options.pollInterval}ms`);
+        logProcessorStart(this.options.productId, this.options.pollInterval);
         // 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)}`);
+                logPollingError(error);
             });
         }, this.options.pollInterval);
-        logInfo('✅ Workflow processor started and monitoring for new features');
+        logProcessorReady();
     }
     /**
      * Stop the workflow processor
@@ -129,7 +61,7 @@ export class WorkflowProcessor {
             clearInterval(this.pollTimer);
             this.pollTimer = undefined;
         }
-        logInfo('⏹️  Workflow processor stopped');
+        logProcessorStop();
     }
     /**
      * Process the next available feature using functional composition
@@ -140,21 +72,15 @@ export class WorkflowProcessor {
             const stats = calculateStats(this.processedFeatures, this.isRunning);
             if (stats.processing > 0) {
                 if (this.options.verbose) {
-                    logInfo(`⏳ Skipping feature fetching as ${stats.processing} feature(s) are currently being processed`);
+                    logSkippingProcessing(stats.processing);
                 }
                 return;
             }
-            // Fetch features using functional approach
-            const fetchFeatures = fetchReadyForDevFeatures({
-                mcpServerUrl: this.options.mcpServerUrl,
-                mcpToken: this.options.mcpToken,
-                productId: this.options.productId,
-                verbose: this.options.verbose,
-            });
-            const features = await fetchFeatures();
+            // Fetch features using unified API
+            const features = await getReadyForDevFeatures(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...');
+                    logNoFeaturesFound();
                 }
                 return;
             }
@@ -162,7 +88,7 @@ export class WorkflowProcessor {
             const nextFeature = findNextFeature(features, this.processedFeatures, this.options.maxRetries);
             if (!nextFeature) {
                 if (this.options.verbose) {
-                    logInfo('🔄 All current features are processed or being processed, continuing to monitor...');
+                    logAllFeaturesProcessed();
                 }
                 return;
             }
@@ -170,7 +96,7 @@ export class WorkflowProcessor {
             await this.processFeature(nextFeature);
         }
         catch (error) {
-            logError(`Error in processNextFeature: ${error instanceof Error ? error.message : String(error)}`);
+            logProcessNextFeatureError(error);
         }
     }
     /**
@@ -178,30 +104,40 @@ export class WorkflowProcessor {
      */
     async processFeature(feature) {
         const featureId = feature.id;
+        // Check if this is a reprocess due to feature update
+        const existingState = this.processedFeatures.get(featureId);
+        if (existingState &&
+            existingState.status === 'completed' &&
+            this.options.verbose) {
+            logInfo(`🔄 Reprocessing feature "${feature.name}" - detected status change`);
+            if (feature.updated_at) {
+                logInfo(`  Previous process: ${existingState.lastAttempt.toISOString()}`);
+                logInfo(`  Feature updated: ${feature.updated_at}`);
+            }
+        }
         // Update state to processing using pure function
         this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createProcessingState(featureId, currentState));
         logProcessingStart(feature, this.options.verbose);
         try {
-            // Run pipeline using functional composition
-            const runPipeline = runCompletePipeline({
+            // Run pipeline using feature workflow with execution mode support
+            const results = await runFeatureWorkflow({
                 featureId,
                 mcpServerUrl: this.options.mcpServerUrl,
                 mcpToken: this.options.mcpToken,
                 verbose: this.options.verbose,
             }, this.config);
-            const results = await runPipeline();
             // Evaluate results using pure function
             const allSuccessful = evaluatePipelineResults(results);
             if (allSuccessful) {
                 // Mark as completed using pure function
                 this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createCompletedState(featureId, currentState));
-                logSuccess(`✅ Feature ${feature.name} completed successfully!`);
+                logFeatureSuccess(feature.name);
                 logPipelineResults(results);
             }
             else {
                 // Mark as failed using pure function
                 this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
-                logError(`❌ Feature ${feature.name} failed in pipeline`);
+                logFeatureFailed(feature.name);
                 logPipelineResults(results);
                 const currentState = this.processedFeatures.get(featureId);
                 logRetryInfo(feature.name, currentState.retryCount, this.options.maxRetries);
@@ -210,7 +146,7 @@ export class WorkflowProcessor {
         catch (error) {
             // Mark as failed using pure function
             this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
-            logError(`❌ Error processing feature ${feature.name}: ${error instanceof Error ? error.message : String(error)}`);
+            logFeatureError(feature.name, error);
         }
     }
     /**
@@ -228,5 +164,7 @@ export const startWorkflowProcessor = (options, config) => async () => {
     await processor.start();
     return processor;
 };
-// Export utility functions for testing and composition
-export { createInitialState, updateFeatureState, shouldProcessFeature, findNextFeature, evaluatePipelineResults, calculateStats, };
+// Re-export core functions for testing and external use
+export { createInitialState, updateFeatureState, createProcessingState, createCompletedState, createFailedState, calculateStats, } from './core/state-manager.js';
+export { shouldProcessFeature, findNextFeature } from './core/feature-filter.js';
+export { evaluatePipelineResults } from './core/pipeline-evaluator.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -32,7 +32,7 @@
   "description": "AI-powered software development CLI tool with comprehensive feature management, code review, technical design, implementation, and testing capabilities using Claude Code SDK and MCP integration",
   "repository": {
     "type": "git",
-    "url": "https://github.com/yourusername/edsger.git"
+    "url": "git+https://github.com/stevenzg/edsger.git"
   },
   "engines": {
     "node": ">=18.0.0"

package/dist/code-implementation/analyzer.d.ts

@@ -1,19 +0,0 @@
-import { EdsgerConfig } from '../types.js';
-export interface CodeImplementationOptions {
-    featureId: string;
-    mcpServerUrl: string;
-    mcpToken: string;
-    verbose?: boolean;
-    baseBranch?: string;
-}
-export interface CodeImplementationResult {
-    featureId: string;
-    branchName: string;
-    implementationSummary: string | null;
-    status: 'success' | 'error';
-    message: string;
-    filesModified?: string[];
-    commitHash?: string;
-}
-export declare const implementFeatureCode: (options: CodeImplementationOptions, config: EdsgerConfig) => Promise<CodeImplementationResult>;
-export declare const checkCodeImplementationRequirements: () => Promise<boolean>;

package/dist/code-implementation/context-fetcher.d.ts

@@ -1,38 +0,0 @@
-export interface CodeImplementationContext {
-    feature: {
-        id: string;
-        name: string;
-        description?: string;
-        technical_design?: string;
-        status: string;
-        product_id: string;
-    };
-    product: {
-        id: string;
-        name: string;
-        description?: string;
-        [key: string]: any;
-    };
-    user_stories: Array<{
-        id: string;
-        title: string;
-        description: string;
-        status: string;
-        [key: string]: any;
-    }>;
-    test_cases: Array<{
-        id: string;
-        name: string;
-        description: string;
-        is_critical: boolean;
-        [key: string]: any;
-    }>;
-}
-/**
- * Fetch all code implementation context information via MCP endpoints
- */
-export declare function fetchCodeImplementationContext(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<CodeImplementationContext>;
-/**
- * Format the context into a readable string for Claude Code
- */
-export declare function formatContextForPrompt(context: CodeImplementationContext): string;

package/dist/code-implementation/context-fetcher.js

@@ -1,147 +0,0 @@
-import { logInfo, logError } from '../logger.js';
-// Helper function to make HTTP requests to the MCP server
-async function callMcpEndpoint(mcpServerUrl, mcpToken, method, params) {
-    try {
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method,
-                params,
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'MCP call failed');
-        }
-        return data.result;
-    }
-    catch (error) {
-        console.error(`MCP call failed for ${method}:`, error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
-/**
- * Fetch all code implementation context information via MCP endpoints
- */
-export async function fetchCodeImplementationContext(mcpServerUrl, mcpToken, featureId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching complete implementation context for feature: ${featureId}`);
-        }
-        // Step 1: Get feature details
-        if (verbose) {
-            logInfo('1/4 Fetching feature details...');
-        }
-        const featureResult = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/get', { feature_id: featureId }));
-        if (!featureResult.features || featureResult.features.length === 0) {
-            throw new Error(`Feature not found: ${featureId}`);
-        }
-        const feature = featureResult.features[0];
-        // Step 2: Get product details
-        if (verbose) {
-            logInfo('2/4 Fetching product details...');
-        }
-        const productResult = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'resources/read', {
-            uri: `product://${feature.product_id}`,
-        }));
-        const productText = productResult.contents?.[0]?.text || '{}';
-        let product;
-        try {
-            product = JSON.parse(productText);
-        }
-        catch {
-            product = {
-                id: feature.product_id,
-                name: 'Unknown Product',
-                description: 'Product information could not be loaded',
-            };
-        }
-        // Step 3: Get user stories
-        if (verbose) {
-            logInfo('3/4 Fetching user stories...');
-        }
-        const userStoriesResult = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/list', { feature_id: featureId }));
-        const user_stories = (userStoriesResult.user_stories || []);
-        // Step 4: Get test cases
-        if (verbose) {
-            logInfo('4/4 Fetching test cases...');
-        }
-        const testCasesResult = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/list', { feature_id: featureId }));
-        const test_cases = (testCasesResult.test_cases || []);
-        // Log summary if verbose
-        if (verbose) {
-            logInfo(`✅ Context fetched successfully:`);
-            logInfo(`   Feature: ${feature.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   User Stories: ${user_stories.length}`);
-            logInfo(`   Test Cases: ${test_cases.length} (${test_cases.filter((tc) => tc.is_critical).length} critical)`);
-            logInfo(`   Technical Design: ${feature.technical_design ? 'Available' : 'Not available'}`);
-        }
-        return {
-            feature,
-            product,
-            user_stories,
-            test_cases,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch code implementation context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}
-/**
- * Format the context into a readable string for Claude Code
- */
-export function formatContextForPrompt(context) {
-    const formatUserStories = (stories) => {
-        if (stories.length === 0)
-            return 'No user stories defined.';
-        return stories
-            .map((story, index) => `${index + 1}. **${story.title}** (Status: ${story.status})
-   ${story.description}`)
-            .join('\n\n');
-    };
-    const formatTestCases = (cases) => {
-        if (cases.length === 0)
-            return 'No test cases defined.';
-        return cases
-            .map((testCase, index) => `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'}
-   ${testCase.description}`)
-            .join('\n\n');
-    };
-    return `# Code Implementation Context
-
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
-- **Description**: ${context.feature.description || 'No description provided'}
-- **Current Status**: ${context.feature.status}
-
-## Product Information
-- **Product**: ${context.product.name}
-- **Product ID**: ${context.product.id}
-- **Description**: ${context.product.description || 'No product description'}
-
-## User Stories (${context.user_stories.length})
-${formatUserStories(context.user_stories)}
-
-## Test Cases (${context.test_cases.length})
-${formatTestCases(context.test_cases)}
-
-## Technical Design
-${context.feature.technical_design || 'No technical design available - you will need to implement based on user stories and test cases'}
-
----
-
-**Implementation Instructions**: Implement the above feature based on the user stories, test cases, and technical design. Follow existing code patterns, create necessary components, APIs, and database changes, and ensure all functionality works as specified.`;
-}

package/dist/feature-analysis/context-fetcher.d.ts

@@ -1,54 +0,0 @@
-export interface FeatureAnalysisContext {
-    feature: {
-        id: string;
-        name: string;
-        description?: string;
-        technical_design?: string;
-        status: string;
-        product_id: string;
-    };
-    product: {
-        id: string;
-        name: string;
-        description?: string;
-        [key: string]: any;
-    };
-    existing_user_stories: Array<{
-        id: string;
-        title: string;
-        description: string;
-        status: string;
-        [key: string]: any;
-    }>;
-    existing_test_cases: Array<{
-        id: string;
-        name: string;
-        description: string;
-        is_critical: boolean;
-        [key: string]: any;
-    }>;
-}
-/**
- * Fetch all feature analysis context information via MCP endpoints
- */
-export declare function fetchFeatureAnalysisContext(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<FeatureAnalysisContext>;
-/**
- * Create new user stories via MCP endpoint
- */
-export declare function createUserStories(mcpServerUrl: string, mcpToken: string, featureId: string, userStories: Array<{
-    title: string;
-    description: string;
-    status?: string;
-}>, verbose?: boolean): Promise<boolean>;
-/**
- * Create new test cases via MCP endpoint
- */
-export declare function createTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, testCases: Array<{
-    name: string;
-    description: string;
-    is_critical?: boolean;
-}>, verbose?: boolean): Promise<boolean>;
-/**
- * Format the context into a readable string for Claude Code
- */
-export declare function formatContextForPrompt(context: FeatureAnalysisContext): string;