edsger 0.41.0 → 0.41.2

package/dist/services/feature-branches.js

@@ -0,0 +1,205 @@
+/**
+ * Feature Branches service for pipeline integration
+ * Allows phases to manage feature branches via MCP
+ */
+import { callMcpEndpoint } from '../api/mcp-client.js';
+/**
+ * List all branches for a feature
+ */
+export async function getFeatureBranches(options) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Fetching feature branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/list', {
+        feature_id: featureId,
+    }));
+    const branches = result?.feature_branches || [];
+    if (verbose) {
+        console.log(`✅ Found ${branches.length} feature branches`);
+    }
+    return branches;
+}
+/**
+ * Get the current active branch for a feature
+ */
+export async function getCurrentBranch(options) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Getting current branch for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/current', {
+        feature_id: featureId,
+    }));
+    return result?.current_branch || null;
+}
+/**
+ * Create feature branches
+ */
+export async function createFeatureBranches(options, branches) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Creating ${branches.length} feature branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/create', {
+        feature_id: featureId,
+        branches: branches,
+    }));
+    const createdBranches = result?.created_branches || [];
+    if (verbose) {
+        console.log(`✅ Created ${createdBranches.length} feature branches`);
+        createdBranches.forEach((b, idx) => {
+            console.log(`   ${idx + 1}. ${b.name} (status: ${b.status})`);
+        });
+    }
+    return createdBranches;
+}
+/**
+ * Update a feature branch
+ */
+export async function updateFeatureBranch(branchId, updates, verbose) {
+    if (verbose) {
+        console.log(`📋 Updating feature branch: ${branchId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/update', {
+        branch_id: branchId,
+        ...updates,
+    }));
+    if (verbose) {
+        console.log(`✅ Feature branch updated successfully`);
+    }
+    return result?.feature_branch;
+}
+/**
+ * Clear all branches for a feature (used before re-planning)
+ */
+export async function clearFeatureBranches(options, force = false) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Clearing feature branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/clear', {
+        feature_id: featureId,
+        force: force,
+    }));
+    const deletedCount = result?.deleted_count || 0;
+    if (verbose) {
+        console.log(`✅ Cleared ${deletedCount} feature branches`);
+    }
+    return deletedCount;
+}
+/**
+ * Format feature branches for context (to include in prompts)
+ */
+export function formatBranchesForContext(branches) {
+    if (!branches || branches.length === 0) {
+        return 'No feature branches defined yet.';
+    }
+    const branchList = branches
+        .map((b, idx) => {
+        const statusEmoji = b.status === 'merged'
+            ? '✅'
+            : b.status === 'in_progress'
+                ? '🔄'
+                : b.status === 'ready_for_review'
+                    ? '👀'
+                    : b.status === 'closed'
+                        ? '❌'
+                        : '⏳';
+        return `${idx + 1}. **${b.name}** ${statusEmoji}
+   - Status: ${b.status}
+   - Branch: ${b.branch_name || 'Not created'}
+   - PR: ${b.pull_request_url || 'Not created'}
+   - Description: ${b.description || 'No description'}`;
+    })
+        .join('\n\n');
+    return `# Feature Branches
+
+${branchList}
+
+Total: ${branches.length} branches
+Merged: ${branches.filter((b) => b.status === 'merged').length}
+In Progress: ${branches.filter((b) => b.status === 'in_progress').length}
+Pending: ${branches.filter((b) => b.status === 'pending').length}`;
+}
+/**
+ * Check if feature has multiple branches planned
+ */
+export async function hasMultipleBranches(options) {
+    const branches = await getFeatureBranches(options);
+    return branches.length > 1;
+}
+/**
+ * Get next pending branch to work on
+ */
+export async function getNextPendingBranch(options) {
+    const branches = await getFeatureBranches(options);
+    return branches.find((b) => b.status === 'pending') || null;
+}
+/**
+ * Check if all branches are completed
+ */
+export async function allBranchesCompleted(options) {
+    const branches = await getFeatureBranches(options);
+    if (branches.length === 0)
+        return true;
+    return branches.every((b) => b.status === 'merged' || b.status === 'closed');
+}
+/**
+ * Get the base branch information for a feature branch.
+ * Returns:
+ * - If base_branch_id is set and that branch is merged: use main
+ * - If base_branch_id is set and that branch is not merged: use that branch's branch_name
+ * - If base_branch_id is null: use main
+ */
+export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main') {
+    // No base branch - start from main
+    if (!branch.base_branch_id) {
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: true,
+        };
+    }
+    // Find the base branch
+    const baseBranch = allBranches.find((b) => b.id === branch.base_branch_id);
+    if (!baseBranch) {
+        // Base branch not found - fall back to main
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: true,
+        };
+    }
+    // Check if base branch is merged
+    if (baseBranch.status === 'merged') {
+        // Base branch is merged to main - we should base on main and rebase if needed
+        return { baseBranch: mainBranch, needsRebase: true, baseBranchMerged: true };
+    }
+    // Base branch is not merged - we should base on that branch
+    if (!baseBranch.branch_name) {
+        // Base branch doesn't have a git branch yet - fall back to main
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: false,
+        };
+    }
+    return {
+        baseBranch: baseBranch.branch_name,
+        needsRebase: false,
+        baseBranchMerged: false,
+    };
+}
+/**
+ * Get branch by ID
+ */
+export async function getBranchById(branchId, verbose) {
+    if (verbose) {
+        console.log(`📋 Fetching feature branch: ${branchId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/get', {
+        branch_id: branchId,
+    }));
+    return result?.feature_branch || null;
+}

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,120 @@
+/**
+ * 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';
+import { writeCodeTests, checkCodeTestingRequirements, } from '../../phases/code-testing/analyzer.js';
+import { refineCodeFromPRFeedback, checkCodeRefineRequirements, } from '../../phases/code-refine/analyzer.js';
+import { verifyAndResolveComments, checkCodeRefineVerificationRequirements, } from '../../phases/code-refine-verification/verifier.js';
+import { reviewPullRequest, checkCodeReviewRequirements, } from '../../phases/code-review/analyzer.js';
+/**
+ * Wrapper for code-refine phase to inject GitHub token
+ */
+const executeCodeRefine = async (options, config) => {
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    if (!githubToken) {
+        return {
+            status: 'error',
+            message: 'GitHub token not found. Set GITHUB_TOKEN or GITHUB_ACCESS_TOKEN environment variable.',
+        };
+    }
+    return refineCodeFromPRFeedback({
+        featureId: options.featureId,
+        mcpServerUrl: options.mcpServerUrl,
+        mcpToken: options.mcpToken,
+        githubToken,
+        verbose: options.verbose,
+    }, config);
+};
+/**
+ * Wrapper for code-refine-verification phase to inject GitHub token
+ */
+const executeCodeRefineVerification = async (options, config) => {
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    if (!githubToken) {
+        return {
+            status: 'error',
+            message: 'GitHub token not found. Set GITHUB_TOKEN or GITHUB_ACCESS_TOKEN environment variable.',
+        };
+    }
+    return verifyAndResolveComments({
+        featureId: options.featureId,
+        mcpServerUrl: options.mcpServerUrl,
+        mcpToken: options.mcpToken,
+        githubToken,
+        config, // Add config parameter for LLM analysis
+        verbose: options.verbose,
+    });
+};
+/**
+ * Wrapper for code-review phase to inject GitHub token
+ */
+const executeCodeReview = async (options, config) => {
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    if (!githubToken) {
+        return {
+            status: 'error',
+            message: 'GitHub token not found. Set GITHUB_TOKEN or GITHUB_ACCESS_TOKEN environment variable.',
+        };
+    }
+    return reviewPullRequest({
+        featureId: options.featureId,
+        mcpServerUrl: options.mcpServerUrl,
+        mcpToken: options.mcpToken,
+        githubToken,
+        verbose: options.verbose,
+    }, config);
+};
+// 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',
+    },
+    {
+        name: 'code-testing',
+        checkRequirements: checkCodeTestingRequirements,
+        execute: writeCodeTests,
+        requirementsError: 'Code testing requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+    {
+        name: 'code-refine',
+        checkRequirements: checkCodeRefineRequirements,
+        execute: executeCodeRefine,
+        requirementsError: 'Code refine requirements not met. Install with: npm install @anthropic-ai/claude-code @octokit/rest',
+    },
+    {
+        name: 'code-refine-verification',
+        checkRequirements: checkCodeRefineVerificationRequirements,
+        execute: executeCodeRefineVerification,
+        requirementsError: 'Code refine verification requirements not met. Install with: npm install @octokit/rest',
+    },
+    {
+        name: 'code-review',
+        checkRequirements: checkCodeReviewRequirements,
+        execute: executeCodeReview,
+        requirementsError: 'Code review requirements not met. Install with: npm install @anthropic-ai/claude-code @octokit/rest',
+    },
+];

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/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>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };