edsger 0.30.0 → 0.30.2

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

@@ -0,0 +1,196 @@
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { createCodeImplementationVerificationSystemPrompt, createCodeImplementationVerificationPrompt, } from './prompts.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(verificationPrompt) {
+    yield userMessage(verificationPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+/**
+ * Verify code implementation against checklist requirements by reviewing git diff
+ */
+export async function verifyCodeImplementationCompliance(options, config) {
+    const { featureId, branchName, baseBranch, featureName, featureDescription, checklistContext, verbose, } = options;
+    if (verbose) {
+        logInfo(`\n🔍 Starting code implementation verification for feature: ${featureName}`);
+        logInfo(`   Branch: ${branchName}`);
+        logInfo(`   Base: ${baseBranch}`);
+    }
+    try {
+        const systemPrompt = createCodeImplementationVerificationSystemPrompt(config);
+        const verificationPrompt = createCodeImplementationVerificationPrompt(featureId, branchName, baseBranch, featureName, featureDescription || '', checklistContext);
+        let lastAssistantResponse = '';
+        let verificationResult = null;
+        if (verbose) {
+            logInfo('🤖 Starting verification agent query...');
+        }
+        // Use Claude Code SDK for verification
+        for await (const message of query({
+            prompt: prompt(verificationPrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 1000,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`   Received message type: ${message.type}`);
+            }
+            // Stream verification process
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        lastAssistantResponse += content.text + '\n';
+                        if (verbose) {
+                            console.log(`\n🔍 ${content.text}`);
+                        }
+                    }
+                    else if (content.type === 'tool_use') {
+                        if (verbose) {
+                            console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
+                        }
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    if (verbose) {
+                        logInfo('\n✅ Code verification completed, parsing results...');
+                    }
+                    try {
+                        const responseText = message.result || lastAssistantResponse;
+                        let jsonResult = null;
+                        // Try to extract JSON from markdown code block
+                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        if (jsonBlockMatch) {
+                            jsonResult = JSON.parse(jsonBlockMatch[1]);
+                        }
+                        else {
+                            // Try to find JSON object containing "verification_result"
+                            let jsonStartIndex = -1;
+                            if (responseText.includes('"verification_result"')) {
+                                const targetIndex = responseText.indexOf('"verification_result"');
+                                // Work backwards to find opening brace
+                                for (let i = targetIndex; i >= 0; i--) {
+                                    if (responseText[i] === '{') {
+                                        jsonStartIndex = i;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (jsonStartIndex !== -1) {
+                                // Find matching closing brace
+                                let braceCount = 0;
+                                let endIndex = jsonStartIndex;
+                                let inString = false;
+                                let escapeNext = false;
+                                for (let i = jsonStartIndex; i < responseText.length; i++) {
+                                    const char = responseText[i];
+                                    if (escapeNext) {
+                                        escapeNext = false;
+                                        continue;
+                                    }
+                                    if (char === '\\' && inString) {
+                                        escapeNext = true;
+                                        continue;
+                                    }
+                                    if (char === '"') {
+                                        inString = !inString;
+                                        continue;
+                                    }
+                                    if (!inString) {
+                                        if (char === '{') {
+                                            braceCount++;
+                                        }
+                                        else if (char === '}') {
+                                            braceCount--;
+                                            if (braceCount === 0) {
+                                                endIndex = i;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                                const jsonStr = responseText.substring(jsonStartIndex, endIndex + 1);
+                                try {
+                                    jsonResult = JSON.parse(jsonStr);
+                                }
+                                catch (parseError) {
+                                    logError(`Failed to parse extracted JSON: ${parseError}`);
+                                    jsonResult = JSON.parse(responseText);
+                                }
+                            }
+                            else {
+                                jsonResult = JSON.parse(responseText);
+                            }
+                        }
+                        if (jsonResult && jsonResult.verification_result) {
+                            verificationResult = jsonResult.verification_result;
+                        }
+                        else {
+                            throw new Error('Invalid JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse verification result: ${error}`);
+                        // Return a failed verification result
+                        verificationResult = {
+                            overall_status: 'failed',
+                            summary: 'Verification failed due to parse error',
+                            confirmed_count: 0,
+                            rejected_count: 1,
+                            uncertain_count: 0,
+                            item_verifications: [],
+                        };
+                    }
+                }
+                else {
+                    logError(`\n⚠️  Verification incomplete: ${message.subtype}`);
+                    verificationResult = {
+                        overall_status: 'failed',
+                        summary: 'Verification incomplete',
+                        confirmed_count: 0,
+                        rejected_count: 1,
+                        uncertain_count: 0,
+                        item_verifications: [],
+                    };
+                }
+            }
+        }
+        if (!verificationResult) {
+            return {
+                overall_status: 'failed',
+                summary: 'No verification result received',
+                confirmed_count: 0,
+                rejected_count: 1,
+                uncertain_count: 0,
+                item_verifications: [],
+            };
+        }
+        if (verbose) {
+            logInfo('\n📊 Verification Results:');
+            logInfo(`   Status: ${verificationResult.overall_status}`);
+            logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
+            logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
+            logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
+        }
+        return verificationResult;
+    }
+    catch (error) {
+        logError(`Code verification failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            overall_status: 'failed',
+            summary: `Verification error: ${error instanceof Error ? error.message : String(error)}`,
+            confirmed_count: 0,
+            rejected_count: 1,
+            uncertain_count: 0,
+            item_verifications: [],
+        };
+    }
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Code Refine Analyzer
+ * Processes GitHub PR review feedback and refines code accordingly
+ */
+import { EdsgerConfig } from '../../types/index.js';
+export interface CodeRefineOptions {
+    featureId: string;
+    githubToken: string;
+    verbose?: boolean;
+    verificationFailureContext?: {
+        attempt: number;
+        suggestions: string[];
+        unresolvedCommentDetails: Array<{
+            commentId: string;
+            author: string;
+            file: string;
+            line: number | null;
+            body: string;
+            failureReason: string;
+            url: string;
+        }>;
+        unresolvedReviewDetails?: Array<{
+            reviewId: number;
+            author: string;
+            state: string;
+            body: string | null;
+        }>;
+    };
+}
+export interface CodeRefineResult {
+    featureId: string;
+    status: 'success' | 'error';
+    message: string;
+    summary?: string;
+    filesModified?: string[];
+    commitsCreated?: number;
+}
+/**
+ * Main code refine function
+ */
+export declare const refineCodeFromPRFeedback: (options: CodeRefineOptions, config: EdsgerConfig) => Promise<CodeRefineResult>;