edsger 0.77.0 → 0.79.0

package/dist/commands/workflow/core/issue-filter.d.ts

@@ -1,16 +0,0 @@
-/**
- * Issue filtering utilities for workflow processor
- * Pure functions for filtering and selecting issues for processing
- */
-import type { IssueInfo } from '../../../types/issues.js';
-import type { IssueProcessingState } from './state-manager.js';
-export declare const shouldProcessIssue: (maxRetries: number) => (issue: IssueInfo, states: Map<string, IssueProcessingState>) => boolean;
-export declare const findNextIssue: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>, maxRetries: number) => IssueInfo | undefined;
-export declare const isIssueProcessing: (issueId: string, states: Map<string, IssueProcessingState>) => boolean;
-export declare const isIssueCompleted: (issueId: string, states: Map<string, IssueProcessingState>) => boolean;
-export declare const isIssueFailed: (issueId: string, states: Map<string, IssueProcessingState>) => boolean;
-export declare const hasReachedMaxRetries: (issueId: string, states: Map<string, IssueProcessingState>, maxRetries: number) => boolean;
-export declare const filterProcessingIssues: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>) => IssueInfo[];
-export declare const filterCompletedIssues: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>) => IssueInfo[];
-export declare const filterFailedIssues: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>) => IssueInfo[];
-export declare const filterAvailableIssues: (issues: readonly IssueInfo[], states: Map<string, IssueProcessingState>, maxRetries: number) => IssueInfo[];

package/dist/commands/workflow/core/issue-filter.js

@@ -1,47 +0,0 @@
-/**
- * Issue filtering utilities for workflow processor
- * Pure functions for filtering and selecting issues for processing
- */
-// Issue filtering functions (pure)
-export const shouldProcessIssue = (maxRetries) => (issue, states) => {
-    const state = states.get(issue.id);
-    // If never processed, should process
-    if (!state) {
-        return true;
-    }
-    // If issue was updated after last processing attempt, should reprocess
-    // This handles cases where user manually changes status back to ready_for_ai
-    if (issue.updated_at) {
-        const issueUpdatedTime = new Date(issue.updated_at).getTime();
-        const lastAttemptTime = state.lastAttempt.getTime();
-        if (issueUpdatedTime > lastAttemptTime) {
-            // Issue 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 findNextIssue = (issues, states, maxRetries) => issues.find((issue) => shouldProcessIssue(maxRetries)(issue, states));
-// Issue status checking functions (pure)
-export const isIssueProcessing = (issueId, states) => {
-    const state = states.get(issueId);
-    return state?.status === 'processing';
-};
-export const isIssueCompleted = (issueId, states) => {
-    const state = states.get(issueId);
-    return state?.status === 'completed';
-};
-export const isIssueFailed = (issueId, states) => {
-    const state = states.get(issueId);
-    return state?.status === 'failed';
-};
-export const hasReachedMaxRetries = (issueId, states, maxRetries) => {
-    const state = states.get(issueId);
-    return state ? state.retryCount >= maxRetries : false;
-};
-// Issue collection filtering functions (pure)
-export const filterProcessingIssues = (issues, states) => issues.filter((issue) => isIssueProcessing(issue.id, states));
-export const filterCompletedIssues = (issues, states) => issues.filter((issue) => isIssueCompleted(issue.id, states));
-export const filterFailedIssues = (issues, states) => issues.filter((issue) => isIssueFailed(issue.id, states));
-export const filterAvailableIssues = (issues, states, maxRetries) => issues.filter((issue) => shouldProcessIssue(maxRetries)(issue, states));

package/dist/commands/workflow/core/pipeline-evaluator.d.ts

@@ -1,24 +0,0 @@
-/**
- * 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/commands/workflow/core/pipeline-evaluator.js

@@ -1,32 +0,0 @@
-/**
- * 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/commands/workflow/core/state-manager.d.ts

@@ -1,24 +0,0 @@
-/**
- * State management utilities for workflow processor
- * Pure functions for handling issue processing states
- */
-export interface IssueProcessingState {
-    readonly issueId: string;
-    readonly retryCount: number;
-    readonly lastAttempt: Date;
-    readonly status: 'processing' | 'completed' | 'failed';
-    readonly issueUpdatedAt?: 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, IssueProcessingState>;
-export declare const createProcessingState: (issueId: string, currentState?: IssueProcessingState) => IssueProcessingState;
-export declare const createCompletedState: (issueId: string, currentState?: IssueProcessingState) => IssueProcessingState;
-export declare const createFailedState: (issueId: string, currentState?: IssueProcessingState) => IssueProcessingState;
-export declare const updateIssueState: (states: Map<string, IssueProcessingState>, issueId: string, updateFn: (currentState?: IssueProcessingState) => IssueProcessingState) => Map<string, IssueProcessingState>;
-export declare const calculateStats: (states: Map<string, IssueProcessingState>, isRunning: boolean) => WorkflowStats;

package/dist/commands/workflow/core/state-manager.js

@@ -1,42 +0,0 @@
-/**
- * State management utilities for workflow processor
- * Pure functions for handling issue processing states
- */
-// State creation functions (pure)
-export const createInitialState = () => new Map();
-export const createProcessingState = (issueId, currentState) => ({
-    issueId,
-    retryCount: currentState ? currentState.retryCount + 1 : 1,
-    lastAttempt: new Date(),
-    status: 'processing',
-});
-export const createCompletedState = (issueId, currentState) => ({
-    issueId,
-    retryCount: currentState ? currentState.retryCount : 1,
-    lastAttempt: new Date(),
-    status: 'completed',
-});
-export const createFailedState = (issueId, currentState) => ({
-    issueId,
-    retryCount: currentState ? currentState.retryCount : 1,
-    lastAttempt: new Date(),
-    status: 'failed',
-});
-// State update function (pure)
-export const updateIssueState = (states, issueId, updateFn) => {
-    const newStates = new Map(states);
-    const currentState = newStates.get(issueId);
-    newStates.set(issueId, 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/commands/workflow/core/workflow-logger.d.ts

@@ -1,23 +0,0 @@
-/**
- * Logging utilities for workflow processor
- * Centralized logging functions for workflow operations
- */
-import type { IssueInfo } from '../../../types/issues.js';
-import type { PipelineResult } from '../../../types/pipeline.js';
-export declare const logProcessingStart: (issue: IssueInfo, verbose?: boolean) => void;
-export declare const logRetryInfo: (issueName: 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 logIssueSuccess: (issueName: string) => void;
-export declare const logIssueFailed: (issueName: string) => void;
-export declare const logIssueError: (issueName: string, error: unknown) => void;
-export declare const logNoIssuesFound: () => void;
-export declare const logAllIssuesProcessed: () => void;
-export declare const logSkippingProcessing: (processingCount: number) => void;
-export declare const logPollingError: (error: unknown) => void;
-export declare const logProcessNextIssueError: (error: unknown) => void;
-export declare const logAutonomousIterationStart: (iteration: number, remainingHours: number) => void;
-export declare const logAutonomousIterationComplete: (iteration: number, summary: string, prUrl?: string) => void;
-export declare const logAutonomousPhaseComplete: (totalIterations: number, elapsedHours: number) => void;

package/dist/commands/workflow/core/workflow-logger.js

@@ -1,77 +0,0 @@
-/**
- * Logging utilities for workflow processor
- * Centralized logging functions for workflow operations
- */
-import { logError, logInfo, logRaw, logSuccess } from '../../../utils/logger.js';
-export const logProcessingStart = (issue, verbose) => {
-    logInfo(`🎯 Processing issue: ${issue.name} (${issue.id})`);
-    if (verbose) {
-        logInfo(`   Description: ${issue.description}`);
-        logInfo(`   Last updated: ${issue.updated_at}`);
-    }
-};
-export const logRetryInfo = (issueName, retryCount, maxRetries) => {
-    if (retryCount < maxRetries) {
-        logInfo(`🔄 Will retry issue ${issueName} (attempt ${retryCount + 1}/${maxRetries})`);
-    }
-    else {
-        logError(`⛔ Max retries reached for issue ${issueName}, marking as permanently failed`);
-    }
-};
-export const logPipelineResults = (results) => {
-    logRaw(`\n${'='.repeat(60)}`);
-    logRaw('Pipeline Results Summary');
-    logRaw('='.repeat(60));
-    results.forEach((result, index) => {
-        const statusIcon = result.status === 'success' ? '✅' : '❌';
-        logRaw(`${index + 1}. ${statusIcon} ${result.phase}: ${result.message}`);
-    });
-    logRaw(`${'='.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 issues');
-};
-export const logProcessorStop = () => {
-    logInfo('⏹️  Workflow processor stopped');
-};
-export const logIssueSuccess = (issueName) => {
-    logSuccess(`✅ Issue ${issueName} completed successfully!`);
-};
-export const logIssueFailed = (issueName) => {
-    logError(`❌ Issue ${issueName} failed in pipeline`);
-};
-export const logIssueError = (issueName, error) => {
-    logError(`❌ Error processing issue ${issueName}: ${error instanceof Error ? error.message : String(error)}`);
-};
-export const logNoIssuesFound = () => {
-    logInfo('🔍 No ready_for_ai issues found, continuing to monitor...');
-};
-export const logAllIssuesProcessed = () => {
-    logInfo('🔄 All current issues are processed or being processed, continuing to monitor...');
-};
-export const logSkippingProcessing = (processingCount) => {
-    logInfo(`⏳ Skipping issue fetching as ${processingCount} issue(s) are currently being processed`);
-};
-export const logPollingError = (error) => {
-    logError(`Error in polling cycle: ${error instanceof Error ? error.message : String(error)}`);
-};
-export const logProcessNextIssueError = (error) => {
-    logError(`Error in processNextIssue: ${error instanceof Error ? error.message : String(error)}`);
-};
-export const logAutonomousIterationStart = (iteration, remainingHours) => {
-    logInfo(`🔄 Autonomous iteration ${iteration} (${remainingHours.toFixed(1)}h remaining)`);
-};
-export const logAutonomousIterationComplete = (iteration, summary, prUrl) => {
-    logSuccess(`✅ Iteration ${iteration}: ${summary}`);
-    if (prUrl) {
-        logInfo(`   PR: ${prUrl}`);
-    }
-};
-export const logAutonomousPhaseComplete = (totalIterations, elapsedHours) => {
-    logSuccess(`🏁 Autonomous development completed: ${totalIterations} iterations in ${elapsedHours.toFixed(2)} hours`);
-};

package/dist/commands/workflow/executors/phase-executor.d.ts

@@ -1,8 +0,0 @@
-/**
- * Phase execution logic for pipeline runner
- */
-import { type EdsgerConfig } from '../../../types/index.js';
-import { type PhaseConfig, type PipelinePhaseOptions, type PipelineResult } from '../../../types/pipeline.js';
-export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runIssueAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runUserStoriesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTestCasesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runPRSplittingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runPRExecutionPhase: (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>, runAutonomousPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runCodeTestingPhase, runFunctionalTestingPhase, runIssueAnalysisPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, };

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