edsger 0.77.0 → 0.78.0

package/dist/commands/workflow/index.js

@@ -1,34 +0,0 @@
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-import { setupWorkflowProcessor } from '../../utils/workflow-utils.js';
-import { WorkflowProcessor } from './processor.js';
-export const runWorkflow = async (options) => {
-    const { config, params } = setupWorkflowProcessor(options);
-    try {
-        // Start workflow processor using functional composition
-        const processor = new WorkflowProcessor(params, config);
-        await processor.start();
-        // Handle graceful shutdown
-        const cleanup = () => {
-            logInfo('\n⏹️  Received shutdown signal, stopping workflow processor...');
-            processor.stop();
-            // Show final stats
-            const stats = processor.getStats();
-            logInfo('📊 Final Statistics:');
-            logInfo(`   Total processed: ${stats.totalProcessed}`);
-            logInfo(`   Completed: ${stats.completed}`);
-            logInfo(`   Failed: ${stats.failed}`);
-            logInfo(`   Processing: ${stats.processing}`);
-            logSuccess('Workflow processor stopped gracefully');
-            process.exit(0);
-        };
-        // Set up signal handlers for graceful shutdown
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-        // Keep the process running
-        process.stdin.resume();
-    }
-    catch (error) {
-        logError(`Workflow processor failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
-    }
-};

package/dist/commands/workflow/issue-coordinator.d.ts

@@ -1,18 +0,0 @@
-/**
- * Issue Coordinator - High-level workflow orchestration
- *
- * Responsibilities:
- * - Fetch issue configuration from API
- * - Execute phases based on workflow field (pending phases in order)
- * - Coordinate issue-level workflow initialization
- * - Handle phase execution results and stop on failure/blocked
- *
- * This is the entry point for issue workflow execution
- */
-import { type EdsgerConfig } from '../../types/index.js';
-import { type PipelinePhaseOptions, type PipelineResult } from '../../types/pipeline.js';
-/**
- * Run workflow for an issue based on its workflow field
- * Executes all pending phases in order, stopping on failure or blocked
- */
-export declare function runIssueWorkflow(options: PipelinePhaseOptions, config: EdsgerConfig): Promise<readonly PipelineResult[]>;

package/dist/commands/workflow/issue-coordinator.js

@@ -1,161 +0,0 @@
-/**
- * Issue Coordinator - High-level workflow orchestration
- *
- * Responsibilities:
- * - Fetch issue configuration from API
- * - Execute phases based on workflow field (pending phases in order)
- * - Coordinate issue-level workflow initialization
- * - Handle phase execution results and stop on failure/blocked
- *
- * This is the entry point for issue workflow execution
- */
-import { getIssue } from '../../api/issues/get-issue.js';
-import { markWorkflowPhaseCompleted } from '../../api/issues/update-issue.js';
-import { cacheBindings, clearBindingsCache, fetchHookBindings, } from '../../services/phase-hooks/index.js';
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { logPhaseResult } from '../../utils/pipeline-logger.js';
-import { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeReviewPhase, runFunctionalTestingPhase, runIssueAnalysisPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, } from './executors/phase-executor.js';
-/**
- * Map workflow phase names (underscore format) to phase runner functions
- * Note: code_refine includes built-in verification loop (similar to technical_design)
- */
-const PHASE_RUNNERS = {
-    issue_analysis: runIssueAnalysisPhase,
-    user_stories_analysis: runUserStoriesAnalysisPhase,
-    test_cases_analysis: runTestCasesAnalysisPhase,
-    technical_design: runTechnicalDesignPhase,
-    branch_planning: runBranchPlanningPhase,
-    code_implementation: runCodeImplementationPhase,
-    pr_splitting: runPRSplittingPhase,
-    pr_execution: runPRExecutionPhase,
-    functional_testing: runFunctionalTestingPhase,
-    code_review: runCodeReviewPhase,
-    code_refine: runCodeRefinePhase,
-    autonomous: runAutonomousPhase,
-};
-/**
- * Get all pending phases from workflow in order
- */
-function getPendingPhases(workflow) {
-    if (!workflow || workflow.length === 0) {
-        return [];
-    }
-    return workflow.filter((phase) => phase.status === 'pending');
-}
-/**
- * Execute a single phase and handle results
- * Returns the result and marks workflow phase as completed if successful
- */
-async function executePhase(phaseName, options, config) {
-    const { issueId, verbose } = options;
-    // Normalize phase name: kebab-case → snake_case (e.g., code-implementation → code_implementation)
-    const normalizedName = phaseName.replace(/-/g, '_');
-    const phaseRunner = PHASE_RUNNERS[normalizedName];
-    if (!phaseRunner) {
-        logWarning(`Unknown workflow phase: ${phaseName}, skipping`);
-        return {
-            issueId,
-            phase: phaseName,
-            status: 'error',
-            message: `Unknown workflow phase: ${phaseName}`,
-        };
-    }
-    if (verbose) {
-        logInfo(`\n🎯 Executing phase: ${normalizedName}`);
-    }
-    // Execute the phase
-    const result = await phaseRunner(options, config);
-    // Log the result
-    logPhaseResult(result, verbose);
-    // Mark workflow phase as completed if successful
-    if (result.status === 'success') {
-        await markWorkflowPhaseCompleted(issueId, normalizedName, verbose);
-    }
-    return result;
-}
-/**
- * Run workflow for an issue based on its workflow field
- * Executes all pending phases in order, stopping on failure or blocked
- */
-export async function runIssueWorkflow(options, config) {
-    const { issueId, verbose } = options;
-    try {
-        // 1. Get issue details to check workflow
-        if (verbose) {
-            logInfo(`🔍 Fetching issue configuration for: ${issueId}`);
-        }
-        const issue = await getIssue(issueId, verbose);
-        // Fetch and cache hook bindings for this issue's product
-        try {
-            const bindings = await fetchHookBindings(issue.product_id, verbose);
-            cacheBindings(issueId, issue.product_id, bindings);
-            if (verbose && bindings.length > 0) {
-                logInfo(`🪝 Loaded ${bindings.length} phase hook binding(s) for product ${issue.product_id}`);
-            }
-        }
-        catch (hookError) {
-            // Hook binding fetch failures should not block workflow execution
-            logWarning(`Failed to fetch phase hook bindings: ${hookError instanceof Error ? hookError.message : String(hookError)}`);
-        }
-        // Debug log workflow data
-        if (verbose) {
-            logInfo(`🔍 Issue data from API:`);
-            logInfo(`  - workflow: ${JSON.stringify(issue.workflow, null, 2)}`);
-        }
-        // 2. Get all pending phases from workflow
-        const pendingPhases = getPendingPhases(issue.workflow);
-        if (pendingPhases.length === 0) {
-            if (verbose) {
-                logInfo('No pending phases in workflow, nothing to execute');
-            }
-            return [
-                {
-                    issueId,
-                    phase: 'workflow-initialization',
-                    status: 'success',
-                    message: 'No pending phases in workflow, nothing to execute',
-                },
-            ];
-        }
-        if (verbose) {
-            logInfo(`📋 Found ${pendingPhases.length} pending phases to execute:`);
-            pendingPhases.forEach((p, i) => logInfo(`   ${i + 1}. ${p.phase}`));
-        }
-        // 3. Execute each pending phase in order
-        const results = [];
-        for (const workflowPhase of pendingPhases) {
-            const result = await executePhase(workflowPhase.phase, options, config);
-            results.push(result);
-            // Stop execution if phase failed or was blocked
-            if (result.status === 'error' || result.status === 'blocked') {
-                if (verbose) {
-                    logInfo(`\n⛔ Stopping workflow execution: ${workflowPhase.phase} ${result.status}`);
-                }
-                break;
-            }
-            // Note: PR creation is now handled within the code-implementation phase itself,
-            // so we no longer need to create it here after code_implementation succeeds.
-        }
-        // Clean up hook bindings cache
-        clearBindingsCache(issueId);
-        if (verbose) {
-            const successCount = results.filter((r) => r.status === 'success').length;
-            logInfo(`\n✅ Workflow execution completed: ${successCount}/${results.length} phases succeeded`);
-        }
-        return results;
-    }
-    catch (error) {
-        clearBindingsCache(issueId);
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to run issue workflow: ${errorMessage}`);
-        // Return error result
-        return [
-            {
-                issueId,
-                phase: 'workflow-initialization',
-                status: 'error',
-                message: `Workflow initialization failed: ${errorMessage}`,
-            },
-        ];
-    }
-}

package/dist/commands/workflow/phase-orchestrator.d.ts

@@ -1,26 +0,0 @@
-/**
- * Phase Orchestrator - Execution engine for workflow phases
- *
- * Responsibilities:
- * - Route execution based on mode (only_*, from_*, full_pipeline)
- * - Orchestrate phase execution sequences and dependencies
- * - Handle error propagation and retry logic
- * - Manage phase result collection and status updates
- *
- * Complete phase flow:
- *   issue-analysis → technical-design → code-implementation →
- *   functional-testing → code-review → code-refine → code-refine-verification
- *
- * Uses functional programming principles for composability
- */
-import { type EdsgerConfig } from '../../types/index.js';
-import { type ExecutionMode, type PipelinePhaseOptions, type PipelineResult } from '../../types/pipeline.js';
-/**
- * Orchestrate phase execution based on execution mode
- * Routes to appropriate phase sequence based on mode (only_*, from_*, full_pipeline)
- */
-export declare const runPipelineByMode: (options: PipelinePhaseOptions, config: EdsgerConfig, executionMode: ExecutionMode) => Promise<readonly PipelineResult[]>;
-/**
- * Run complete pipeline for an issue using functional composition (legacy)
- */
-export declare const runCompletePipeline: (options: PipelinePhaseOptions, config: EdsgerConfig) => () => Promise<readonly PipelineResult[]>;