edsger 0.2.3 → 0.2.5

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/code-implementation-verification.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/feature-analysis/analyzer-helpers.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Helper functions for feature analysis
+ * Extracted from analyzer.ts to improve modularity and testability
+ */
+import { EdsgerConfig, FeatureAnalysisResult } from '../../types/index.js';
+import { FeatureAnalysisContext } from './context-fetcher.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { ChecklistVerificationResult } from '../feature-analysis-verification/index.js';
+interface ParsedAnalysisResult {
+    analysis?: any;
+    error?: string;
+}
+/**
+ * Parse JSON result from Claude Code response
+ */
+export declare function parseAnalysisResult(responseText: string): ParsedAnalysisResult;
+/**
+ * Execute a single analysis query
+ */
+export declare function executeAnalysisQuery(currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<any | null>;
+interface VerificationCycleResult {
+    passed: boolean;
+    verificationResult: ChecklistVerificationResult | null;
+    nextPrompt?: string;
+}
+/**
+ * Perform verification and determine if iteration should continue
+ * This function only verifies - it does NOT manage artifacts (save/delete/update)
+ */
+export declare function performVerificationCycle(structuredAnalysisResult: any, checklistContext: ChecklistPhaseContext | null, context: FeatureAnalysisContext, config: EdsgerConfig, currentIteration: number, maxIterations: number, mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<VerificationCycleResult>;
+/**
+ * Save analysis artifacts as draft and return their IDs
+ */
+export declare function saveAnalysisArtifactsAsDraft(mcpServerUrl: string, mcpToken: string, featureId: string, created_user_stories: any[], created_test_cases: any[], verbose?: boolean): Promise<{
+    userStoryIds: string[];
+    testCaseIds: string[];
+}>;
+/**
+ * Update artifacts to ready status after successful verification
+ */
+export declare function updateArtifactsToReady(mcpServerUrl: string, mcpToken: string, userStoryIds: string[], testCaseIds: string[], verbose?: boolean): Promise<void>;
+/**
+ * Delete artifacts after verification failure
+ */
+export declare function deleteArtifacts(mcpServerUrl: string, mcpToken: string, userStoryIds: string[], testCaseIds: string[], verbose?: boolean): Promise<void>;
+/**
+ * Save analysis artifacts (user stories and test cases) - Legacy function for non-verification flows
+ */
+export declare function saveAnalysisArtifacts(mcpServerUrl: string, mcpToken: string, featureId: string, created_user_stories: any[], created_test_cases: any[], status: string, verbose?: boolean): Promise<void>;
+/**
+ * Build the final analysis result object
+ */
+export declare function buildAnalysisResult(featureId: string, context: FeatureAnalysisContext, structuredAnalysisResult: any, currentIteration: number): FeatureAnalysisResult;
+/**
+ * Build error result when verification fails after all iterations
+ */
+export declare function buildVerificationFailureResult(featureId: string, context: FeatureAnalysisContext, verificationResult: ChecklistVerificationResult, checklist_results: any, checklist_item_results: any, currentIteration: number): FeatureAnalysisResult;
+/**
+ * Build error result when no analysis results are received
+ */
+export declare function buildNoResultsError(featureId: string, context: FeatureAnalysisContext): FeatureAnalysisResult;
+export {};