edsger 0.3.2 → 0.4.0

package/dist/phases/code-refine/context-fetcher.d.ts

@@ -56,10 +56,6 @@ export declare function fetchPRReviews(octokit: Octokit, owner: string, repo: st
  * Fetch PR review comments
  */
 export declare function fetchPRReviewComments(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<PRReviewComment[]>;
-/**
- * Fetch technical design via MCP
- */
-export declare function fetchTechnicalDesign(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<string | undefined>;
 /**
  * Fetch user stories via MCP
  */

package/dist/phases/code-refine/context-fetcher.js

@@ -54,51 +54,6 @@ export async function fetchPRReviewComments(octokit, owner, repo, prNumber, verb
     }
     return comments;
 }
-/**
- * Fetch technical design via MCP
- */
-export async function fetchTechnicalDesign(mcpServerUrl, mcpToken, featureId, verbose) {
-    try {
-        if (verbose) {
-            console.log(`📐 Fetching technical design for ${featureId}...`);
-        }
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'technical-design/get',
-                params: {
-                    feature_id: featureId,
-                },
-            }),
-        });
-        if (!response.ok) {
-            if (verbose) {
-                console.log(`⚠️ Could not fetch technical design: ${response.status}`);
-            }
-            return undefined;
-        }
-        const data = await response.json();
-        if (data.error || !data.result) {
-            if (verbose) {
-                console.log(`⚠️ Technical design not available`);
-            }
-            return undefined;
-        }
-        return data.result.technical_design;
-    }
-    catch (error) {
-        if (verbose) {
-            console.log(`⚠️ Error fetching technical design: ${error}`);
-        }
-        return undefined;
-    }
-}
 /**
  * Fetch user stories via MCP
  */
@@ -116,7 +71,7 @@ export async function fetchUserStories(mcpServerUrl, mcpToken, featureId, verbos
             body: JSON.stringify({
                 jsonrpc: '2.0',
                 id: 1,
-                method: 'user-stories/list',
+                method: 'user_stories/list',
                 params: {
                     feature_id: featureId,
                 },
@@ -161,7 +116,7 @@ export async function fetchTestCases(mcpServerUrl, mcpToken, featureId, verbose)
             body: JSON.stringify({
                 jsonrpc: '2.0',
                 id: 1,
-                method: 'test-cases/list',
+                method: 'test_cases/list',
                 params: {
                     feature_id: featureId,
                 },
@@ -209,10 +164,9 @@ export async function fetchCodeRefineContext(mcpServerUrl, mcpToken, featureId,
         auth: githubToken,
     });
     // Fetch PR reviews and comments
-    const [reviews, reviewComments, technicalDesign, userStories, testCases] = await Promise.all([
+    const [reviews, reviewComments, userStories, testCases] = await Promise.all([
         fetchPRReviews(octokit, owner, repo, prNumber, verbose),
         fetchPRReviewComments(octokit, owner, repo, prNumber, verbose),
-        fetchTechnicalDesign(mcpServerUrl, mcpToken, featureId, verbose),
         fetchUserStories(mcpServerUrl, mcpToken, featureId, verbose),
         fetchTestCases(mcpServerUrl, mcpToken, featureId, verbose),
     ]);
@@ -226,7 +180,7 @@ export async function fetchCodeRefineContext(mcpServerUrl, mcpToken, featureId,
         repo,
         reviews,
         reviewComments,
-        technicalDesign,
+        technicalDesign: feature.technical_design,
         userStories,
         testCases,
     };

package/dist/phases/code-refine/retry-handler.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Code refine retry handler for pipeline execution
+ * Handles verification failures and retries code refine with suggestions
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { PipelinePhaseOptions, PipelineResult } from '../../types/pipeline.js';
+export declare const MAX_REFINE_ATTEMPTS = 10;
+export interface CodeRefineRetryOptions {
+    options: PipelinePhaseOptions;
+    config: EdsgerConfig;
+    results: PipelineResult[];
+    verbose?: boolean;
+}
+/**
+ * Handle code refine verification failures with automatic retry
+ */
+export declare function handleCodeRefineWithRetry({ options, config, results, verbose, }: CodeRefineRetryOptions): Promise<PipelineResult>;

package/dist/phases/code-refine/retry-handler.js

@@ -0,0 +1,109 @@
+/**
+ * Code refine retry handler for pipeline execution
+ * Handles verification failures and retries code refine with suggestions
+ */
+import { logPhaseResult } from '../../utils/pipeline-logger.js';
+import { runCodeRefinePhase, runCodeRefineVerificationPhase, } from '../../workflow-runner/executors/phase-executor.js';
+import { updateFeatureStatusForPhase } from '../../api/features/index.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+export const MAX_REFINE_ATTEMPTS = 10;
+/**
+ * Handle code refine verification failures with automatic retry
+ */
+export async function handleCodeRefineWithRetry({ options, config, results, verbose, }) {
+    let verificationResult;
+    let refineAttempt = 0;
+    do {
+        // 1. Run code refine phase
+        const codeRefineResult = await runCodeRefinePhase(options, config);
+        results.push(logPhaseResult(codeRefineResult, verbose));
+        // If code refine failed, stop immediately
+        if (codeRefineResult.status === 'error') {
+            if (verbose) {
+                console.log(`❌ Code refine failed: ${codeRefineResult.message}. Cannot proceed to verification.`);
+            }
+            return codeRefineResult;
+        }
+        // 2. Run code refine verification
+        verificationResult = await runCodeRefineVerificationPhase(options, config);
+        results.push(logPhaseResult(verificationResult, verbose));
+        // If verification passed, we're done
+        if (verificationResult.status === 'success') {
+            if (verbose) {
+                console.log(`✅ Code refine verification passed. All PR comments have been addressed.`);
+            }
+            break;
+        }
+        // Verification failed - check if we should retry
+        if (refineAttempt < MAX_REFINE_ATTEMPTS) {
+            refineAttempt++;
+            if (verbose) {
+                console.log(`⚠️  Code refine verification failed. Retrying... (Attempt ${refineAttempt}/${MAX_REFINE_ATTEMPTS})`);
+            }
+            // Extract verification failure details
+            const verificationData = verificationResult.data;
+            const unresolvedComments = verificationData?.unresolvedComments ||
+                verificationData?.unresolved_comments ||
+                0;
+            const suggestions = verificationData?.suggestions || [];
+            const unresolvedDetails = verificationData?.unresolvedCommentDetails ||
+                verificationData?.unresolved_comment_details ||
+                [];
+            // Log audit event for verification failure with suggestions
+            await logFeaturePhaseEvent(options.mcpServerUrl, options.mcpToken, {
+                featureId: options.featureId,
+                eventType: 'phase_failed',
+                phase: 'code_refine_verification',
+                result: 'error',
+                metadata: {
+                    attempt: refineAttempt,
+                    unresolved_comments: unresolvedComments,
+                    suggestions: suggestions,
+                    unresolved_comment_details: unresolvedDetails,
+                    will_retry: true,
+                },
+                errorMessage: verificationResult.message,
+            }, verbose);
+            if (verbose && suggestions.length > 0) {
+                console.log(`\n💡 Suggestions for next iteration:`);
+                suggestions.forEach((suggestion) => {
+                    console.log(`   ${suggestion}`);
+                });
+                console.log('');
+            }
+            // Remove the failed verification result - we'll add the new one after retry
+            results.pop();
+            // Update status to indicate we're retrying code refine
+            await updateFeatureStatusForPhase({ mcpServerUrl: options.mcpServerUrl, mcpToken: options.mcpToken }, options.featureId, 'code-refine', verbose);
+            // Also remove the code refine result so it can be retried
+            results.pop();
+        }
+        else {
+            // Max attempts reached
+            if (verbose) {
+                console.log(`⚠️  Maximum refine attempts (${MAX_REFINE_ATTEMPTS}) reached. Verification still failing.`);
+            }
+            // Log final failure with all details
+            const verificationData = verificationResult.data;
+            const suggestions = verificationData?.suggestions || [];
+            const unresolvedDetails = verificationData?.unresolvedCommentDetails ||
+                verificationData?.unresolved_comment_details ||
+                [];
+            await logFeaturePhaseEvent(options.mcpServerUrl, options.mcpToken, {
+                featureId: options.featureId,
+                eventType: 'phase_failed',
+                phase: 'code_refine_verification',
+                result: 'error',
+                metadata: {
+                    attempt: refineAttempt,
+                    max_attempts_reached: true,
+                    suggestions: suggestions,
+                    unresolved_comment_details: unresolvedDetails,
+                },
+                errorMessage: `Max attempts reached: ${verificationResult.message}`,
+            }, verbose);
+            break;
+        }
+    } while (refineAttempt <= MAX_REFINE_ATTEMPTS);
+    return verificationResult;
+}

package/dist/phases/code-refine-verification/verifier.d.ts

@@ -9,14 +9,34 @@ export interface CodeRefineVerificationOptions {
     githubToken: string;
     verbose?: boolean;
 }
-export interface CodeRefineVerificationResult {
+export interface CodeRefineVerificationData {
     featureId: string;
-    status: 'success' | 'error';
-    message: string;
+    totalReviews: number;
+    unresolvedReviews: number;
     totalComments: number;
     resolvedComments: number;
     unresolvedComments: number;
     commentsMarkedResolved?: number;
+    suggestions?: string[];
+    unresolvedReviewDetails?: Array<{
+        reviewId: number;
+        author: string;
+        state: string;
+        body: string | null;
+        submittedAt: string | null;
+    }>;
+    unresolvedCommentDetails?: Array<{
+        commentId: number;
+        author: string;
+        file: string;
+        line: number | null;
+        body: string;
+    }>;
+}
+export interface CodeRefineVerificationResult {
+    status: 'success' | 'error';
+    message: string;
+    data: CodeRefineVerificationData;
 }
 /**
  * Verify and resolve PR review comments

package/dist/phases/code-refine-verification/verifier.js

@@ -4,7 +4,7 @@
  */
 import { Octokit } from '@octokit/rest';
 import { logInfo, logError } from '../../utils/logger.js';
-import { parsePullRequestUrl, fetchPRReviewComments, } from '../code-refine/context-fetcher.js';
+import { parsePullRequestUrl, fetchPRReviews, fetchPRReviewComments, } from '../code-refine/context-fetcher.js';
 import { getFeature } from '../../api/features/get-feature.js';
 /**
  * Check if a review comment thread is resolved
@@ -107,36 +107,55 @@ export async function verifyAndResolveComments(options) {
         const octokit = new Octokit({
             auth: githubToken,
         });
-        // Fetch all review comments
-        const reviewComments = await fetchPRReviewComments(octokit, owner, repo, prNumber, verbose);
-        if (reviewComments.length === 0) {
+        // Fetch all reviews requesting changes and review comments
+        const [reviews, reviewComments] = await Promise.all([
+            fetchPRReviews(octokit, owner, repo, prNumber, verbose),
+            fetchPRReviewComments(octokit, owner, repo, prNumber, verbose),
+        ]);
+        if (reviews.length === 0 && reviewComments.length === 0) {
             if (verbose) {
-                logInfo('✅ No review comments found. Verification complete.');
+                logInfo('✅ No reviews or review comments found. Verification complete.');
             }
             return {
-                featureId,
                 status: 'success',
-                message: 'No review comments to verify',
-                totalComments: 0,
-                resolvedComments: 0,
-                unresolvedComments: 0,
+                message: 'No reviews or review comments to verify',
+                data: {
+                    featureId,
+                    totalReviews: 0,
+                    unresolvedReviews: 0,
+                    totalComments: 0,
+                    resolvedComments: 0,
+                    unresolvedComments: 0,
+                },
             };
         }
         // Check which comments are resolved
         if (verbose) {
-            logInfo(`🔍 Checking ${reviewComments.length} review comments...`);
+            if (reviews.length > 0) {
+                logInfo(`🔍 Checking ${reviews.length} reviews requesting changes...`);
+            }
+            if (reviewComments.length > 0) {
+                logInfo(`🔍 Checking ${reviewComments.length} review comments...`);
+            }
         }
+        // Check review comments resolution status
         const commentStatus = await Promise.all(reviewComments.map(async (comment) => {
             const isResolved = await isCommentThreadResolved(octokit, owner, repo, prNumber, comment.id, verbose);
             return { comment, isResolved };
         }));
         const resolvedComments = commentStatus.filter((c) => c.isResolved);
         const unresolvedComments = commentStatus.filter((c) => !c.isResolved);
+        // Check reviews - they need to be dismissed or re-reviewed
+        // We consider reviews as "unresolved" if they are still in CHANGES_REQUESTED state
+        const unresolvedReviews = reviews.filter((review) => review.state === 'CHANGES_REQUESTED');
         if (verbose) {
-            logInfo(`📊 Status: ${resolvedComments.length} resolved, ${unresolvedComments.length} unresolved`);
+            logInfo(`📊 Comments: ${resolvedComments.length} resolved, ${unresolvedComments.length} unresolved`);
+            if (reviews.length > 0) {
+                logInfo(`📊 Reviews: ${reviews.length - unresolvedReviews.length} addressed, ${unresolvedReviews.length} still requesting changes`);
+            }
         }
-        // If all comments are resolved, mark them as resolved on GitHub
-        if (unresolvedComments.length === 0) {
+        // If all comments are resolved AND no reviews requesting changes, success
+        if (unresolvedComments.length === 0 && unresolvedReviews.length === 0) {
             if (verbose) {
                 logInfo('✅ All comments have been addressed! Marking them as resolved...');
             }
@@ -150,34 +169,118 @@ export async function verifyAndResolveComments(options) {
             if (verbose) {
                 logInfo(`✅ Marked ${markedCount} comments as resolved on GitHub`);
             }
+            const successMessage = reviews.length > 0
+                ? 'All reviews and review comments have been addressed and resolved'
+                : 'All review comments have been addressed and resolved';
             return {
-                featureId,
                 status: 'success',
-                message: 'All review comments have been addressed and resolved',
-                totalComments: reviewComments.length,
-                resolvedComments: resolvedComments.length,
-                unresolvedComments: 0,
-                commentsMarkedResolved: markedCount,
+                message: successMessage,
+                data: {
+                    featureId,
+                    totalReviews: reviews.length,
+                    unresolvedReviews: 0,
+                    totalComments: reviewComments.length,
+                    resolvedComments: resolvedComments.length,
+                    unresolvedComments: 0,
+                    commentsMarkedResolved: markedCount,
+                },
             };
         }
         else {
             if (verbose) {
-                logInfo(`⚠️  ${unresolvedComments.length} comments still need to be addressed`);
+                if (unresolvedReviews.length > 0) {
+                    logInfo(`⚠️  ${unresolvedReviews.length} reviews still requesting changes`);
+                    unresolvedReviews.forEach((review) => {
+                        logInfo(`  - Review ${review.id} by @${review.user.login}`);
+                        if (review.body) {
+                            logInfo(`    ${review.body.substring(0, 100)}...`);
+                        }
+                    });
+                }
+                if (unresolvedComments.length > 0) {
+                    logInfo(`⚠️  ${unresolvedComments.length} comments still need to be addressed`);
+                    unresolvedComments.forEach(({ comment }) => {
+                        logInfo(`  - Comment ${comment.id} by @${comment.user.login}`);
+                        if (comment.path) {
+                            logInfo(`    File: ${comment.path}:${comment.line || '?'}`);
+                        }
+                        logInfo(`    ${comment.body.substring(0, 100)}...`);
+                    });
+                }
+            }
+            // Build suggestions for code-refine phase
+            const suggestions = [];
+            // Add reviews information
+            if (unresolvedReviews.length > 0) {
+                suggestions.push(`Found ${unresolvedReviews.length} reviews still requesting changes:`);
+                unresolvedReviews.forEach((review) => {
+                    suggestions.push(`- Review by @${review.user.login}${review.body ? `: ${review.body}` : ''}`);
+                });
+                suggestions.push('');
+            }
+            // Add comments information
+            if (unresolvedComments.length > 0) {
+                suggestions.push(`Found ${unresolvedComments.length} unresolved PR review comments:`);
                 unresolvedComments.forEach(({ comment }) => {
-                    logInfo(`  - Comment ${comment.id} by @${comment.user.login}`);
-                    if (comment.path) {
-                        logInfo(`    File: ${comment.path}:${comment.line || '?'}`);
-                    }
-                    logInfo(`    ${comment.body.substring(0, 100)}...`);
+                    const location = comment.path
+                        ? `${comment.path}${comment.line ? `:${comment.line}` : ''}`
+                        : 'General comment';
+                    suggestions.push(`- [${location}] ${comment.user.login}: ${comment.body}`);
                 });
+                suggestions.push('');
+            }
+            suggestions.push('Suggestions for next code-refine iteration:');
+            if (unresolvedReviews.length > 0) {
+                suggestions.push('1. Address the overall concerns raised in the reviews requesting changes');
+                suggestions.push('2. Make significant improvements to satisfy the reviewers');
+            }
+            if (unresolvedComments.length > 0) {
+                suggestions.push(`${unresolvedReviews.length > 0 ? '3' : '1'}. Carefully read each unresolved comment above`);
+                suggestions.push(`${unresolvedReviews.length > 0 ? '4' : '2'}. Locate the specific file and line mentioned in each comment`);
+                suggestions.push(`${unresolvedReviews.length > 0 ? '5' : '3'}. Make the requested changes to address the reviewer feedback`);
+            }
+            suggestions.push(`${unresolvedReviews.length > 0 || unresolvedComments.length > 0 ? (unresolvedReviews.length > 0 ? (unresolvedComments.length > 0 ? '6' : '3') : '4') : '1'}. Ensure your changes fully resolve the concerns raised`);
+            suggestions.push(`${unresolvedReviews.length > 0 || unresolvedComments.length > 0 ? (unresolvedReviews.length > 0 ? (unresolvedComments.length > 0 ? '7' : '4') : '5') : '2'}. Test your changes before committing`);
+            // Build detailed unresolved info
+            const unresolvedCommentDetails = unresolvedComments.map(({ comment }) => ({
+                commentId: comment.id,
+                author: comment.user.login,
+                file: comment.path || 'unknown',
+                line: comment.line,
+                body: comment.body,
+            }));
+            const unresolvedReviewDetails = unresolvedReviews.map((review) => ({
+                reviewId: review.id,
+                author: review.user.login,
+                state: review.state,
+                body: review.body,
+                submittedAt: review.submitted_at,
+            }));
+            const totalUnresolved = unresolvedReviews.length + unresolvedComments.length;
+            let errorMessage = '';
+            if (unresolvedReviews.length > 0 && unresolvedComments.length > 0) {
+                errorMessage = `${unresolvedReviews.length} reviews and ${unresolvedComments.length} comments still need to be addressed`;
+            }
+            else if (unresolvedReviews.length > 0) {
+                errorMessage = `${unresolvedReviews.length} reviews still requesting changes`;
+            }
+            else {
+                errorMessage = `${unresolvedComments.length} review comments still need to be addressed`;
             }
             return {
-                featureId,
                 status: 'error',
-                message: `${unresolvedComments.length} review comments still need to be addressed`,
-                totalComments: reviewComments.length,
-                resolvedComments: resolvedComments.length,
-                unresolvedComments: unresolvedComments.length,
+                message: errorMessage,
+                data: {
+                    featureId,
+                    totalReviews: reviews.length,
+                    unresolvedReviews: unresolvedReviews.length,
+                    totalComments: reviewComments.length,
+                    resolvedComments: resolvedComments.length,
+                    unresolvedComments: unresolvedComments.length,
+                    suggestions,
+                    unresolvedReviewDetails,
+                    unresolvedCommentDetails,
+                },
             };
         }
     }
@@ -185,12 +288,20 @@ export async function verifyAndResolveComments(options) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logError(`Code refine verification failed: ${errorMessage}`);
         return {
-            featureId,
             status: 'error',
             message: `Verification failed: ${errorMessage}`,
-            totalComments: 0,
-            resolvedComments: 0,
-            unresolvedComments: 0,
+            data: {
+                featureId,
+                totalReviews: 0,
+                unresolvedReviews: 0,
+                totalComments: 0,
+                resolvedComments: 0,
+                unresolvedComments: 0,
+                suggestions: [
+                    `Verification failed with error: ${errorMessage}`,
+                    'Please check the error message and try again',
+                ],
+            },
         };
     }
 }

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

@@ -173,15 +173,36 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
             }, verbose);
         }
         else {
+            // Extract additional failure details from result data
+            const failureMetadata = {
+                duration_ms: phaseDuration,
+            };
+            // For verification phases, include suggestions and details
+            if (name.includes('verification') &&
+                result.data &&
+                typeof result.data === 'object') {
+                const data = result.data;
+                if (data.suggestions) {
+                    failureMetadata.suggestions = data.suggestions;
+                }
+                if (data.unresolvedCommentDetails ||
+                    data.unresolved_comment_details) {
+                    failureMetadata.unresolved_comment_details =
+                        data.unresolvedCommentDetails || data.unresolved_comment_details;
+                }
+                if (data.unresolvedComments !== undefined ||
+                    data.unresolved_comments !== undefined) {
+                    failureMetadata.unresolved_comments =
+                        data.unresolvedComments ?? data.unresolved_comments;
+                }
+            }
             await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
                 featureId,
                 eventType: 'phase_failed',
                 phase: name.replace(/-/g, '_'),
                 result: 'error',
-                metadata: {
-                    duration_ms: phaseDuration,
-                },
-                errorMessage: result.summary || 'Phase execution failed',
+                metadata: failureMetadata,
+                errorMessage: result.summary || result.message || 'Phase execution failed',
             }, verbose);
         }
         return {

package/dist/workflow-runner/pipeline-runner.js

@@ -4,9 +4,10 @@
  * Uses functional programming principles
  */
 import { updateFeatureStatusForPhase } from '../api/features/index.js';
-import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, } from './executors/phase-executor.js';
 import { logPipelineStart, logPhaseResult, logPipelineComplete, shouldContinuePipeline, } from '../utils/pipeline-logger.js';
 import { handleTestFailuresWithRetry } from '../phases/functional-testing/test-retry-handler.js';
+import { handleCodeRefineWithRetry } from '../phases/code-refine/retry-handler.js';
 import { handlePullRequestCreation } from '../phases/pull-request/handler.js';
 /**
  * Run pipeline based on execution mode
@@ -267,19 +268,18 @@ const runFromFunctionalTesting = async (options, config) => {
 };
 /**
  * Run only code refine phase (refine code based on PR feedback)
+ * Includes automatic retry loop for verification failures
  */
 const runOnlyCodeRefine = async (options, config) => {
     const { featureId, verbose } = options;
     logPipelineStart(featureId, verbose);
     const results = [];
-    // 1. Code Refine - Address PR review feedback
-    const codeRefineResult = await runCodeRefinePhase(options, config);
-    results.push(logPhaseResult(codeRefineResult, verbose));
-    if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
-    }
-    // 2. Code Refine Verification - Verify all comments are addressed
-    const verificationResult = await runCodeRefineVerificationPhase(options, config);
-    results.push(logPhaseResult(verificationResult, verbose));
+    // Code Refine with automatic retry for verification failures
+    await handleCodeRefineWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
     return logPipelineComplete(results, verbose);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "type": "module",
   "main": "dist/index.js",
   "bin": {