edsger 0.76.0 → 0.78.0

package/dist/commands/workflow/executors/phase-executor.js

@@ -1,338 +0,0 @@
-/**
- * Phase execution logic for pipeline runner
- */
-import { checkApprovalBeforePhaseExecution } from '../../../api/issues/approval-checker.js';
-import { updateIssueStatusForPhase } from '../../../api/issues/index.js';
-import { logIssuePhaseEvent } from '../../../services/audit-logs.js';
-import { getChecklistsForPhase, processChecklistItemResultsFromResponse, processChecklistResultsFromResponse, validateChecklistsForPhase, validateRequiredChecklistResults, } from '../../../services/checklist.js';
-import { runHooksForPhase } from '../../../services/phase-hooks/index.js';
-import { logDebug, logInfo, logWarning } from '../../../utils/logger.js';
-import { phaseConfigs } from '../config/phase-configs.js';
-/**
- * Enrich failure metadata with verification-specific details
- */
-function enrichFailureMetadata(metadata, phaseName, data) {
-    if (!phaseName.includes('verification') ||
-        !data ||
-        typeof data !== 'object') {
-        return;
-    }
-    if (data.suggestions) {
-        metadata.suggestions = data.suggestions;
-    }
-    if (data.unresolvedCommentDetails || data.unresolved_comment_details) {
-        metadata.unresolved_comment_details =
-            data.unresolvedCommentDetails || data.unresolved_comment_details;
-    }
-    if (data.unresolvedComments !== undefined ||
-        data.unresolved_comments !== undefined) {
-        metadata.unresolved_comments =
-            data.unresolvedComments ?? data.unresolved_comments;
-    }
-}
-/**
- * Log checklist processing results in verbose mode
- */
-function logChecklistProcessResult(processResult, phaseName, format, verbose) {
-    if (!verbose) {
-        return;
-    }
-    if (processResult.created > 0) {
-        logDebug(`Processed ${processResult.created} checklist ${format} results from ${phaseName} phase`, verbose);
-    }
-    if (processResult.errors.length > 0) {
-        logWarning(`${processResult.errors.length} errors processing checklist ${format} results`);
-        processResult.errors.forEach((error) => logDebug(`   - ${error}`, verbose));
-    }
-}
-/**
- * Process checklist results from phase response data
- */
-async function processPhaseChecklistResults(result, options, name, verbose) {
-    try {
-        const checklistItemResults = result.data?.checklist_item_results;
-        if (checklistItemResults && Array.isArray(checklistItemResults)) {
-            const processResult = await processChecklistItemResultsFromResponse(options, name, checklistItemResults, verbose);
-            logChecklistProcessResult(processResult, name, 'item', verbose);
-            return;
-        }
-        // Fallback to old format for backward compatibility
-        const checklistResults = result.data?.checklist_results;
-        if (checklistResults && Array.isArray(checklistResults)) {
-            const processResult = await processChecklistResultsFromResponse(options, checklistResults, verbose);
-            logChecklistProcessResult(processResult, name, 'legacy', verbose);
-        }
-    }
-    catch (processError) {
-        if (verbose) {
-            logWarning(`Failed to process checklist results from ${name} phase: ${processError instanceof Error ? processError.message : String(processError)}`);
-        }
-    }
-}
-/**
- * Validate checklists and log completion status
- */
-async function validateAndLogChecklists(options, name, checklistContext, issueId, verbose) {
-    try {
-        const strictValidation = await validateRequiredChecklistResults(options, name, verbose);
-        if (!strictValidation.success) {
-            return {
-                validation: null,
-                error: {
-                    issueId,
-                    phase: name,
-                    status: 'error',
-                    message: `Checklist validation failed: ${strictValidation.error}`,
-                    data: {
-                        checklist_context: checklistContext,
-                        checklist_validation_error: strictValidation.error,
-                        missing_checklists: strictValidation.missingChecklists,
-                    },
-                },
-            };
-        }
-        const checklistValidation = await validateChecklistsForPhase(options, name);
-        if (verbose) {
-            logDebug(`Checklist validation: ${checklistValidation.summary}`, verbose);
-        }
-        if (checklistValidation.checklists_validation.length > 0) {
-            const completedCount = checklistValidation.checklists_validation.filter((v) => v.is_completed).length;
-            const totalCount = checklistValidation.checklists_validation.length;
-            if (verbose) {
-                logDebug(`Checklist results status: ${completedCount}/${totalCount} checklists have results`, verbose);
-            }
-            if (!checklistValidation.all_completed) {
-                checklistValidation.checklists_validation.forEach((validation) => {
-                    if (!validation.is_completed) {
-                        logInfo(`   - ${validation.checklist_name} (${validation.role}): ${validation.status}`);
-                    }
-                });
-            }
-        }
-        return { validation: checklistValidation };
-    }
-    catch (validationError) {
-        return {
-            validation: null,
-            error: {
-                issueId,
-                phase: name,
-                status: 'error',
-                message: `Checklist validation error: ${validationError instanceof Error ? validationError.message : String(validationError)}`,
-                data: {
-                    checklist_context: checklistContext,
-                    checklist_validation_error: validationError instanceof Error
-                        ? validationError.message
-                        : String(validationError),
-                },
-            },
-        };
-    }
-}
-// Higher-order function for phase execution
-export const createPhaseRunner = (phaseConfig) => async (options, config) => {
-    const { issueId, verbose } = options;
-    const { name, execute } = phaseConfig;
-    // Track phase duration for logging
-    const phaseStartTime = Date.now();
-    try {
-        // CHECK APPROVAL BEFORE EXECUTING PHASE
-        // This checks if the current issue status has been approved
-        if (verbose) {
-            logDebug(`Checking approval before executing ${name} phase...`, verbose);
-        }
-        // The approval system keys configs on snake_case phase names
-        // (matching the workflow JSONB vocabulary), so convert from the
-        // kebab-case orchestrator name before checking.
-        const phaseSnakeCase = name.replace(/-/g, '_');
-        const approvalCheck = await checkApprovalBeforePhaseExecution(issueId, phaseSnakeCase, verbose);
-        if (!approvalCheck.canProceed) {
-            // Current status requires approval but hasn't been approved yet
-            // Block phase execution and return blocked result
-            if (verbose) {
-                logWarning(`Phase ${name} blocked: ${approvalCheck.message || 'Waiting for approval'}`);
-            }
-            return {
-                issueId,
-                phase: name,
-                status: 'blocked',
-                message: approvalCheck.message ||
-                    'Phase execution blocked - waiting for approval of current issue status',
-                data: {
-                    approval_required: true,
-                    approval_id: approvalCheck.approvalId,
-                },
-            };
-        }
-        // Approval check passed, proceed with phase execution
-        if (verbose && approvalCheck.requiresApproval) {
-            logDebug(`Approval verified for current status. Proceeding with ${name} phase.`, verbose);
-        }
-        // Update issue status to reflect current phase
-        await updateIssueStatusForPhase(issueId, name, verbose);
-        if (verbose) {
-            logDebug(`Starting ${name} for: ${issueId}`, verbose);
-        }
-        // Log phase start
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_started',
-            phase: name.replace(/-/g, '_'),
-            result: 'info',
-            metadata: {
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        // Fetch checklists for this phase as context
-        let checklistContext = null;
-        try {
-            checklistContext = await getChecklistsForPhase(options, name);
-            if (verbose && checklistContext.checklists.length > 0) {
-                logDebug(`Found ${checklistContext.checklists.length} checklists for ${name} phase`, verbose);
-            }
-        }
-        catch (checklistError) {
-            // Always log checklist fetch errors, not just in verbose mode
-            logWarning(`Failed to fetch checklists for ${name} phase: ${checklistError instanceof Error ? checklistError.message : String(checklistError)}`);
-            // Log more details in verbose mode
-            if (verbose && checklistError instanceof Error) {
-                logDebug(`Details: ${checklistError.stack}`, verbose);
-            }
-        }
-        // Run 'before' hooks
-        const beforeHooks = await runHooksForPhase({
-            issueId,
-            phase: name,
-            hookPoint: 'before',
-            verbose,
-        });
-        if (beforeHooks.blocked) {
-            return {
-                issueId,
-                phase: name,
-                status: 'blocked',
-                message: `Phase ${name} blocked by pre-execution hook`,
-                data: { hook_results: beforeHooks.results },
-            };
-        }
-        // Execute the phase with checklist context
-        // Note: Coaching loop runs INSIDE each phase (between execute and verify),
-        // not here. Each phase handles its own coaching integration.
-        const result = (await execute(options, config, checklistContext));
-        // Run 'after' hooks
-        const afterHooks = await runHooksForPhase({
-            issueId,
-            phase: name,
-            hookPoint: 'after',
-            phaseResult: result,
-            verbose,
-        });
-        if (afterHooks.blocked) {
-            return {
-                issueId,
-                phase: name,
-                status: 'blocked',
-                message: `Phase ${name} blocked by post-execution hook`,
-                data: { phase_result: result, hook_results: afterHooks.results },
-            };
-        }
-        // Process checklist results from phase response if phase was successful
-        if (result.status === 'success') {
-            await processPhaseChecklistResults(result, options, name, verbose);
-        }
-        // Strictly validate checklist results after phase execution
-        let checklistValidation = null;
-        if (result.status === 'success') {
-            const validationOutcome = await validateAndLogChecklists(options, name, checklistContext, issueId, verbose);
-            if (validationOutcome.error) {
-                return validationOutcome.error;
-            }
-            checklistValidation = validationOutcome.validation;
-        }
-        // Log phase completion
-        const phaseEndTime = Date.now();
-        const phaseDuration = phaseEndTime - phaseStartTime;
-        if (result.status === 'success') {
-            await logIssuePhaseEvent({
-                issueId,
-                eventType: 'phase_completed',
-                phase: name.replace(/-/g, '_'),
-                result: 'success',
-                metadata: {
-                    duration_ms: phaseDuration,
-                    iterations: result.data?.iterations,
-                    artifacts: result.data,
-                    checklist_validation: checklistValidation,
-                },
-            }, verbose);
-        }
-        else {
-            // Extract additional failure details from result data
-            const failureMetadata = {
-                duration_ms: phaseDuration,
-            };
-            // For verification phases, include suggestions and details
-            enrichFailureMetadata(failureMetadata, name, result.data);
-            await logIssuePhaseEvent({
-                issueId,
-                eventType: 'phase_failed',
-                phase: name.replace(/-/g, '_'),
-                result: 'error',
-                metadata: failureMetadata,
-                errorMessage: result.summary || result.message || 'Phase execution failed',
-            }, verbose);
-        }
-        return {
-            issueId,
-            phase: name,
-            status: result.status === 'success' ? 'success' : 'error',
-            message: result.status === 'success'
-                ? `${name.replace('-', ' ')} completed successfully`
-                : `${name.replace('-', ' ')} failed`,
-            data: {
-                ...result,
-                checklist_context: checklistContext,
-                checklist_validation: checklistValidation,
-            },
-        };
-    }
-    catch (error) {
-        // Run 'on_error' hooks (best effort — never mask the original error)
-        try {
-            await runHooksForPhase({
-                issueId,
-                phase: name,
-                hookPoint: 'on_error',
-                error: error instanceof Error ? error : new Error(String(error)),
-                verbose,
-            });
-        }
-        catch {
-            // Swallow hook errors to preserve original error reporting
-        }
-        // Log phase failure for exceptions
-        const phaseEndTime = Date.now();
-        const phaseDuration = phaseEndTime - phaseStartTime;
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_failed',
-            phase: name.replace(/-/g, '_'),
-            result: 'error',
-            metadata: {
-                duration_ms: phaseDuration,
-                error_type: 'exception',
-            },
-            errorMessage: error instanceof Error ? error.message : String(error),
-        }, verbose);
-        return {
-            issueId,
-            phase: name,
-            status: 'error',
-            message: `${name.replace('-', ' ')} failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-};
-// Create phase runners using the configuration
-const [runIssueAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runPRSplittingPhase, runPRExecutionPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
-// Export individual phase runners for granular control
-export { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runCodeTestingPhase, runFunctionalTestingPhase, runIssueAnalysisPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, };

package/dist/commands/workflow/index.d.ts

@@ -1,2 +0,0 @@
-import { type CliOptions } from '../../types/index.js';
-export declare const runWorkflow: (options: CliOptions) => Promise<void>;

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[]>;