edsger 0.30.0 → 0.30.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/utils/git-branch-manager.d.ts

@@ -212,6 +212,8 @@ export interface RebaseWithConflictResolutionOptions {
      * GitHub to recalculate the PR diff.
      */
     forcePushAfterRebase?: boolean;
+    /** GitHub App installation token for authenticated push */
+    githubToken?: string;
 }
 /**
  * Switch to feature branch and rebase with base branch, with optional automatic conflict resolution

package/dist/utils/git-branch-manager.js

@@ -7,6 +7,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { Octokit } from '@octokit/rest';
 import { logInfo, logError } from './logger.js';
+import { gitForcePush } from './git-push.js';
 /**
  * Get current Git branch name
  */
@@ -689,7 +690,7 @@ export async function syncFeatBranchWithMain(featBranch, githubToken, owner, rep
  * @returns Object containing the previous branch name and conflict resolution result
  */
 export async function switchToFeatureBranchAndRebaseAsync(options) {
-    const { featureBranch, baseBranch = 'main', rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, baseBranchCompleted = false, } = options;
+    const { featureBranch, baseBranch = 'main', rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, baseBranchCompleted = false, githubToken, } = options;
     // Determine the actual target branch for rebase
     // If rebaseTargetBranch is set (e.g., main), use it; otherwise use baseBranch
     const actualRebaseTarget = rebaseTargetBranch || baseBranch;
@@ -864,23 +865,9 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
         }
         // Force push after rebase to trigger GitHub to recalculate PR diff
         if (forcePushAfterRebase) {
-            try {
-                if (verbose) {
-                    logInfo(`📤 Force pushing ${featureBranch} to trigger PR diff recalculation...`);
-                }
-                execSync(`git push --force-with-lease origin ${featureBranch}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                if (verbose) {
-                    logInfo(`✅ Successfully force pushed ${featureBranch}`);
-                }
-            }
-            catch (pushError) {
-                if (verbose) {
-                    logInfo(`⚠️  Could not force push ${featureBranch}: ${pushError instanceof Error ? pushError.message : String(pushError)}`);
-                }
-                // Don't fail the whole process if push fails
+            const pushResult = gitForcePush({ branchName: featureBranch, token: githubToken, verbose });
+            if (!pushResult.success && verbose) {
+                logInfo(`⚠️  Could not force push ${featureBranch}: ${pushResult.error}`);
             }
         }
         return { previousBranch };
@@ -908,23 +895,9 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
                 }
                 // Force push after rebase to trigger GitHub to recalculate PR diff
                 if (forcePushAfterRebase) {
-                    try {
-                        if (verbose) {
-                            logInfo(`📤 Force pushing ${featureBranch} to trigger PR diff recalculation...`);
-                        }
-                        execSync(`git push --force-with-lease origin ${featureBranch}`, {
-                            encoding: 'utf-8',
-                            stdio: verbose ? 'inherit' : 'pipe',
-                        });
-                        if (verbose) {
-                            logInfo(`✅ Successfully force pushed ${featureBranch}`);
-                        }
-                    }
-                    catch (pushError) {
-                        if (verbose) {
-                            logInfo(`⚠️  Could not force push ${featureBranch}: ${pushError instanceof Error ? pushError.message : String(pushError)}`);
-                        }
-                        // Don't fail the whole process if push fails
+                    const pushResult = gitForcePush({ branchName: featureBranch, token: githubToken, verbose });
+                    if (!pushResult.success && verbose) {
+                        logInfo(`⚠️  Could not force push ${featureBranch}: ${pushResult.error}`);
                     }
                 }
                 return {

package/dist/utils/git-push.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared git push utilities with GitHub App credential helper support.
+ *
+ * Uses `git -c credential.helper=...` to pass the token securely per-command,
+ * matching the pattern established in workspace-manager.ts for clone/fetch.
+ * Uses `execFileSync` instead of `execSync` to avoid shell metacharacter injection.
+ */
+export interface GitPushOptions {
+    branchName: string;
+    token?: string;
+    verbose?: boolean;
+    cwd?: string;
+}
+export interface GitPushResult {
+    success: boolean;
+    error?: string;
+    method?: 'push-u' | 'push' | 'force-with-lease';
+}
+/**
+ * Build git args with optional credential helper prefix.
+ * When a token is provided, prepends `-c credential.helper=...` so git
+ * authenticates with the GitHub App installation token.
+ */
+export declare function buildCredentialArgs(token?: string): string[];
+/**
+ * Push a branch to remote with three-level fallback:
+ *   1. git push -u origin <branch>
+ *   2. git push origin <branch>
+ *   3. git push --force-with-lease origin <branch>
+ *
+ * When `token` is provided, each command uses a credential helper for authentication.
+ */
+export declare function gitPush(options: GitPushOptions): GitPushResult;
+/**
+ * Force push a branch using --force-with-lease.
+ * Used after rebase operations to update the remote branch.
+ */
+export declare function gitForcePush(options: GitPushOptions): GitPushResult;
+/**
+ * Push the current branch to remote.
+ * Resolves the current branch name first, then delegates to gitPush.
+ */
+export declare function gitPushCurrentBranch(options: Omit<GitPushOptions, 'branchName'>): GitPushResult;

package/dist/utils/git-push.js

@@ -0,0 +1,127 @@
+/**
+ * Shared git push utilities with GitHub App credential helper support.
+ *
+ * Uses `git -c credential.helper=...` to pass the token securely per-command,
+ * matching the pattern established in workspace-manager.ts for clone/fetch.
+ * Uses `execFileSync` instead of `execSync` to avoid shell metacharacter injection.
+ */
+import { execFileSync } from 'child_process';
+import { logInfo } from './logger.js';
+/**
+ * Build git args with optional credential helper prefix.
+ * When a token is provided, prepends `-c credential.helper=...` so git
+ * authenticates with the GitHub App installation token.
+ */
+export function buildCredentialArgs(token) {
+    if (!token)
+        return [];
+    // First clear any existing credential helpers (e.g. osxkeychain) with an empty value,
+    // then set our custom helper. This ensures the token is used instead of stale keychain creds.
+    const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=${token}"; }; f`;
+    return ['-c', 'credential.helper=', '-c', `credential.helper=${credentialHelper}`];
+}
+/**
+ * Push a branch to remote with three-level fallback:
+ *   1. git push -u origin <branch>
+ *   2. git push origin <branch>
+ *   3. git push --force-with-lease origin <branch>
+ *
+ * When `token` is provided, each command uses a credential helper for authentication.
+ */
+export function gitPush(options) {
+    const { branchName, token, verbose, cwd } = options;
+    const credArgs = buildCredentialArgs(token);
+    const execOpts = {
+        cwd,
+        stdio: (verbose ? 'inherit' : 'pipe'),
+    };
+    if (verbose) {
+        logInfo(`📤 Pushing branch ${branchName} to remote...`);
+    }
+    // Try 1: push -u (set upstream tracking)
+    try {
+        execFileSync('git', [...credArgs, 'push', '-u', 'origin', branchName], execOpts);
+        return { success: true, method: 'push-u' };
+    }
+    catch {
+        // fall through
+    }
+    // Try 2: plain push
+    try {
+        execFileSync('git', [...credArgs, 'push', 'origin', branchName], execOpts);
+        return { success: true, method: 'push' };
+    }
+    catch {
+        // fall through
+    }
+    // Try 3: force push with lease
+    if (verbose) {
+        logInfo(`⚠️  Push rejected, attempting force push with lease...`);
+    }
+    try {
+        execFileSync('git', [...credArgs, 'push', '--force-with-lease', 'origin', branchName], execOpts);
+        if (verbose) {
+            logInfo(`✅ Successfully force pushed ${branchName}`);
+        }
+        return { success: true, method: 'force-with-lease' };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Force push a branch using --force-with-lease.
+ * Used after rebase operations to update the remote branch.
+ */
+export function gitForcePush(options) {
+    const { branchName, token, verbose, cwd } = options;
+    const credArgs = buildCredentialArgs(token);
+    const execOpts = {
+        cwd,
+        stdio: (verbose ? 'inherit' : 'pipe'),
+    };
+    if (verbose) {
+        logInfo(`📤 Force pushing ${branchName} to remote...`);
+    }
+    try {
+        execFileSync('git', [...credArgs, 'push', '--force-with-lease', 'origin', branchName], execOpts);
+        if (verbose) {
+            logInfo(`✅ Successfully force pushed ${branchName}`);
+        }
+        return { success: true, method: 'force-with-lease' };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Push the current branch to remote.
+ * Resolves the current branch name first, then delegates to gitPush.
+ */
+export function gitPushCurrentBranch(options) {
+    const { token, verbose, cwd } = options;
+    let branchName;
+    try {
+        branchName = execFileSync('git', ['branch', '--show-current'], {
+            encoding: 'utf-8',
+            cwd,
+            stdio: 'pipe',
+        }).trim();
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to resolve current branch: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    if (!branchName) {
+        return { success: false, error: 'Could not determine current branch (detached HEAD?)' };
+    }
+    return gitPush({ branchName, token, verbose, cwd });
+}

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';