edsger 0.2.2 → 0.2.4

package/dist/phases/code-implementation/analyzer-helpers.js

@@ -0,0 +1,177 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
+import { formatChecklistsForContext, processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
+import { verifyCodeImplementationCompliance, } from '../code-implementation-verification/index.js';
+import { createCodeImplementationImprovementPrompt } from '../../prompts/code-implementation-improvement.js';
+/**
+ * Perform a complete verification cycle:
+ * 1. Verify code implementation against checklist
+ * 2. Log results to audit logs
+ * 3. Create improvement prompt if verification failed
+ */
+export async function performVerificationCycle(branchName, baseBranch, checklistContext, featureId, featureName, featureDescription, config, currentIteration, maxIterations, mcpServerUrl, mcpToken, verbose) {
+    // If no checklist, verification passes automatically
+    if (!checklistContext || checklistContext.checklists.length === 0) {
+        if (verbose) {
+            logInfo('ℹ️  No checklists to verify - skipping verification');
+        }
+        return {
+            passed: true,
+            verificationResult: null,
+            nextPrompt: null,
+        };
+    }
+    if (verbose) {
+        logInfo(`\n🔍 Verifying code implementation (iteration ${currentIteration}/${maxIterations})...`);
+    }
+    // Format checklist context for verification
+    const checklistInfo = formatChecklistsForContext(checklistContext);
+    // Perform verification
+    const verificationResult = await verifyCodeImplementationCompliance({
+        featureId,
+        branchName,
+        baseBranch,
+        featureName,
+        featureDescription,
+        checklistContext: checklistInfo,
+        verbose,
+    }, config);
+    // Determine if verification passed
+    const verificationPassed = verificationResult.rejected_count === 0;
+    // Log verification result
+    if (verificationPassed) {
+        if (verbose) {
+            logInfo(`✅ Code verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
+        }
+        await logFeatureVerificationEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            phase: 'code_implementation',
+            iteration: currentIteration,
+            result: 'success',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                summary: verificationResult.summary,
+            },
+        }, verbose);
+        // Create checklist results based on verification result
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId, mcpServerUrl, mcpToken }, 'code_implementation', checklistItemResults, verbose);
+    }
+    else {
+        logError(`❌ Iteration ${currentIteration}: Code verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
+        await logFeatureVerificationEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            phase: 'code_implementation',
+            iteration: currentIteration,
+            result: 'error',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                rejected_items: verificationResult.item_verifications
+                    .filter((item) => item.verification_status === 'rejected')
+                    .map((item) => ({
+                    checklist_item_id: item.checklist_item_id,
+                    reason: item.verification_reason || 'No reason provided',
+                    concerns: item.concerns || [],
+                    improvement_suggestions: item.improvement_suggestions || [],
+                })),
+                uncertain_items: verificationResult.item_verifications
+                    .filter((item) => item.verification_status === 'uncertain')
+                    .map((item) => ({
+                    checklist_item_id: item.checklist_item_id,
+                    reason: item.verification_reason || 'No reason provided',
+                    concerns: item.concerns || [],
+                    improvement_suggestions: item.improvement_suggestions || [],
+                })),
+                summary: verificationResult.summary,
+                overall_suggestions: verificationResult.overall_suggestions || [],
+            },
+        }, verbose);
+    }
+    // If verification failed and we have iterations left, create improvement prompt
+    let nextPrompt = null;
+    if (!verificationPassed && currentIteration < maxIterations) {
+        nextPrompt = createCodeImplementationImprovementPrompt(verificationResult, branchName, baseBranch);
+        if (verbose) {
+            logInfo(`\n📝 Created improvement prompt for next iteration (${maxIterations - currentIteration} attempts remaining)`);
+        }
+    }
+    else if (!verificationPassed) {
+        // Max iterations reached - create checklist results based on final verification
+        if (verbose) {
+            logInfo(`\n📋 Creating checklist results for final iteration (max iterations reached)`);
+        }
+        // Create checklist results for all items (both passed and failed)
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId, mcpServerUrl, mcpToken }, 'code_implementation', checklistItemResults, verbose);
+    }
+    return {
+        passed: verificationPassed,
+        verificationResult,
+        nextPrompt,
+    };
+}
+/**
+ * Build successful implementation result
+ */
+export function buildImplementationResult(featureId, branchName, implementationSummary, filesModified, commitHash, iterations, checklistResults, checklistItemResults) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary,
+        status: 'success',
+        message: 'Code implementation completed successfully',
+        filesModified,
+        commitHash,
+        data: {
+            checklist_results: checklistResults,
+            checklist_item_results: checklistItemResults,
+        },
+    };
+}
+/**
+ * Build verification failure result
+ */
+export function buildVerificationFailureResult(featureId, branchName, implementationSummary, filesModified, commitHash, verificationResult, iterations) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary,
+        status: 'error',
+        message: `Code implementation verification failed after ${iterations} iterations. Code committed for manual review.`,
+        filesModified,
+        commitHash,
+        data: {
+            verification_failed: true,
+            verification_summary: verificationResult.summary,
+            rejected_count: verificationResult.rejected_count,
+            uncertain_count: verificationResult.uncertain_count,
+            improvement_suggestions: verificationResult.overall_suggestions || [],
+        },
+    };
+}
+/**
+ * Build error result for no implementation
+ */
+export function buildNoResultsError(featureId, branchName) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary: null,
+        status: 'error',
+        message: 'Code implementation failed - no results produced',
+    };
+}

package/dist/phases/code-implementation/analyzer.d.ts

@@ -6,6 +6,7 @@ export interface CodeImplementationOptions {
     mcpToken: string;
     verbose?: boolean;
     baseBranch?: string;
+    maxVerificationIterations?: number;
 }
 export interface CodeImplementationResult {
     featureId: string;
@@ -27,6 +28,7 @@ export interface CodeImplementationResult {
             value?: any;
             notes?: string;
         }>;
+        [key: string]: any;
     };
 }
 export declare const implementFeatureCode: (options: CodeImplementationOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<CodeImplementationResult>;