edsger 0.41.1 → 0.41.3

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

@@ -0,0 +1,86 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature, getUserStories, getTestCases, } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+/**
+ * Fetch all code implementation context information via MCP endpoints
+ */
+export async function fetchCodeImplementationContext(featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching complete code implementation context for feature: ${featureId}`);
+        }
+        // Fetch all required data in parallel for better performance
+        const [feature, user_stories, test_cases] = await Promise.all([
+            getFeature(featureId, verbose),
+            getUserStories(featureId, verbose),
+            getTestCases(featureId, verbose),
+        ]);
+        const product = await getProduct(feature.product_id, verbose);
+        if (verbose) {
+            logInfo(`✅ Code implementation context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   User Stories: ${user_stories.length}`);
+            logInfo(`   Test Cases: ${test_cases.length}`);
+            logInfo(`   Technical Design: ${feature.technical_design ? 'Available' : 'Not available'}`);
+        }
+        return {
+            feature,
+            product,
+            user_stories,
+            test_cases,
+            technical_design: feature.technical_design,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch code implementation context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}
+/**
+ * Format the context into a readable string for Claude Code
+ */
+export function formatContextForPrompt(context) {
+    const formatUserStories = (stories) => {
+        if (stories.length === 0)
+            return 'No user stories defined.';
+        return stories
+            .map((story, index) => `${index + 1}. **${story.title}** (Status: ${story.status})
+   ${story.description}`)
+            .join('\n\n');
+    };
+    const formatTestCases = (cases) => {
+        if (cases.length === 0)
+            return 'No test cases defined.';
+        return cases
+            .map((testCase, index) => `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'}
+   ${testCase.description}`)
+            .join('\n\n');
+    };
+    return `# Code Implementation Context
+
+## Feature Information
+- **ID**: ${context.feature.id}
+- **Name**: ${context.feature.name}
+- **Description**: ${context.feature.description || 'No description provided'}
+- **Current Status**: ${context.feature.status}
+
+## Product Information
+- **Product**: ${context.product.name}
+- **Product ID**: ${context.product.id}
+- **Description**: ${context.product.description || 'No product description'}
+
+## User Stories to Implement (${context.user_stories.length})
+${formatUserStories(context.user_stories)}
+
+## Test Cases to Satisfy (${context.test_cases.length})
+${formatTestCases(context.test_cases)}
+
+## Technical Design
+${context.technical_design || 'No technical design available - implement based on user stories and test cases'}
+
+---
+
+**Implementation Instructions**: Based on the above requirements, user stories, test cases, and technical design, implement the complete feature functionality. Ensure all user stories are implemented and all test cases can pass.`;
+}

package/dist/phases/code-implementation/index.js

@@ -170,9 +170,7 @@ message, lastAssistantResponse, featureId, verbose
     }
     return null;
 }
-export const implementFeatureCode = async (options, config, checklistContext
-// eslint-disable-next-line complexity -- orchestration function coordinating full code implementation lifecycle
-) => {
+export const implementFeatureCode = async (options, config, checklistContext) => {
     const { featureId, verbose, baseBranch = 'main' } = options;
     if (verbose) {
         logInfo(`Starting code implementation for feature ID: ${featureId}`);

package/dist/phases/code-implementation/mcp-server.d.ts

@@ -0,0 +1 @@
+export declare const createCodeImplementationMcpServer: () => import("@anthropic-ai/claude-code").McpSdkServerConfigWithInstance;

package/dist/phases/code-implementation/mcp-server.js

@@ -0,0 +1,93 @@
+import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code';
+import { z } from 'zod';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+// Create an SDK MCP server with custom tools for code implementation
+export const createCodeImplementationMcpServer = () => {
+    return createSdkMcpServer({
+        name: 'edsger-code-implementation-mcp',
+        version: '1.0.0',
+        tools: [
+            tool('get_complete_feature_info', 'Get comprehensive feature information including product, user stories, test cases, and technical design', {
+                feature_id: z
+                    .string()
+                    .describe('Feature ID to get complete information for'),
+            }, async (args) => {
+                try {
+                    // Get feature details
+                    const featureResult = (await callMcpEndpoint('features/get', {
+                        feature_id: args.feature_id,
+                    }));
+                    if (!featureResult.features ||
+                        featureResult.features.length === 0) {
+                        throw new Error('Feature not found');
+                    }
+                    const feature = featureResult.features[0];
+                    // Get product details
+                    const productResult = (await callMcpEndpoint('resources/read', {
+                        uri: `product://${feature.product_id}`,
+                    }));
+                    const productText = productResult.contents?.[0]?.text || '{}';
+                    let productInfo;
+                    try {
+                        productInfo = JSON.parse(productText);
+                    }
+                    catch {
+                        productInfo = {
+                            id: feature.product_id,
+                            name: 'Unknown Product',
+                        };
+                    }
+                    // Get user stories
+                    const userStoriesResult = (await callMcpEndpoint('user_stories/list', { feature_id: args.feature_id }));
+                    // Get test cases
+                    const testCasesResult = (await callMcpEndpoint('test_cases/list', {
+                        feature_id: args.feature_id,
+                    }));
+                    const completeInfo = {
+                        feature,
+                        product: productInfo,
+                        user_stories: userStoriesResult.user_stories || [],
+                        test_cases: testCasesResult.test_cases || [],
+                        technical_design: feature.technical_design || null,
+                    };
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(completeInfo, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    console.error('Error in get_complete_feature_info:', error);
+                    throw error;
+                }
+            }),
+            tool('verify_implementation_complete', 'Verify that the code implementation is complete and all tests pass', {
+                feature_id: z
+                    .string()
+                    .describe('Feature ID to verify implementation'),
+                implementation_summary: z
+                    .string()
+                    .describe('Summary of what was implemented'),
+            }, async (args) => {
+                // This tool is a placeholder for verification
+                // In reality, it would check test results, lint results, etc.
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                verified: true,
+                                feature_id: args.feature_id,
+                                summary: args.implementation_summary,
+                                message: 'Implementation verification complete',
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }),
+        ],
+    });
+};

package/dist/phases/code-implementation/prompts-improvement.d.ts

@@ -0,0 +1,5 @@
+import { ChecklistVerificationResult } from '../code-implementation-verification/index.js';
+/**
+ * Create a prompt for the implementation agent to improve code based on verification feedback
+ */
+export declare const createCodeImplementationImprovementPrompt: (verificationResult: ChecklistVerificationResult, branchName: string, baseBranch: string) => string;

package/dist/phases/code-implementation/prompts-improvement.js

@@ -0,0 +1,108 @@
+/**
+ * Create a prompt for the implementation agent to improve code based on verification feedback
+ */
+export const createCodeImplementationImprovementPrompt = (verificationResult, branchName, baseBranch) => {
+    // Format rejected items with specific feedback and improvement suggestions
+    const rejectedItemsSection = verificationResult.item_verifications
+        .filter((v) => v.verification_status === 'rejected')
+        .map((v, index) => {
+        return `### Rejected Requirement ${index + 1}
+**Checklist Item ID**: ${v.checklist_item_id}
+**Satisfaction Status**: ${v.is_satisfied ? '✅ Satisfied' : '❌ Not Satisfied'}
+**Verification Result**: ❌ REJECTED
+**Reason**: ${v.verification_reason}
+${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
+${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**💡 Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
+`;
+    })
+        .join('\n---\n');
+    // Format uncertain items with improvement suggestions
+    const uncertainItemsSection = verificationResult.item_verifications
+        .filter((v) => v.verification_status === 'uncertain')
+        .map((v, index) => {
+        return `### Uncertain Requirement ${index + 1}
+**Checklist Item ID**: ${v.checklist_item_id}
+**Satisfaction Status**: ${v.is_satisfied ? '✅ Satisfied' : '⚠️ Partially Satisfied'}
+**Verification Result**: ⚠️ UNCERTAIN
+**Reason**: ${v.verification_reason}
+${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
+${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**💡 Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
+`;
+    })
+        .join('\n---\n');
+    return `# Code Review Feedback - Improvements Required
+
+Your code implementation was reviewed by an independent code reviewer, and **${verificationResult.rejected_count} checklist requirements were NOT SATISFIED** and **${verificationResult.uncertain_count} requirements are PARTIALLY SATISFIED**.
+
+## Code Review Summary
+${verificationResult.summary}
+
+## Results Breakdown
+- ✅ Satisfied: ${verificationResult.confirmed_count}
+- ❌ Not Satisfied: ${verificationResult.rejected_count}
+- ⚠️ Partially Satisfied: ${verificationResult.uncertain_count}
+
+${verificationResult.overall_suggestions && verificationResult.overall_suggestions.length > 0 ? `## 💡 Overall Improvement Suggestions\n\n${verificationResult.overall_suggestions.map((s) => `- ${s}`).join('\n')}\n\n` : ''}
+
+${verificationResult.rejected_count > 0 ? `## ❌ Unsatisfied Requirements\n\n${rejectedItemsSection}` : ''}
+
+${verificationResult.uncertain_count > 0 ? `## ⚠️ Partially Satisfied Requirements\n\n${uncertainItemsSection}` : ''}
+
+---
+
+## Your Task: Improve Your Code Implementation
+
+You are currently on branch **${branchName}** (based on ${baseBranch}). You need to **improve your code** to satisfy the checklist requirements.
+
+**What You Should Do**:
+
+1. **Review the improvement suggestions** provided above for each rejected/uncertain requirement
+2. **Follow the specific, actionable suggestions** from the code reviewer
+3. **Modify your code** to address the concerns and implement the suggested improvements
+4. **Fix code quality issues**, bugs, or security concerns identified
+5. **Ensure all requirements are adequately satisfied** based on the feedback
+6. **Commit your improvements** to the same branch
+
+**IMPORTANT Guidelines**:
+- **Pay close attention to the 💡 Improvement Suggestions** - these tell you exactly what to fix
+- **Address all concerns** raised by the reviewer
+- **Test your changes** to ensure they work correctly
+- **Follow best practices** for code quality, security, and performance
+- **Commit your improvements** with a clear message explaining what was fixed
+- The code will be reviewed again after your improvements
+
+**Git Workflow**:
+1. You are already on branch ${branchName}
+2. Make the necessary code changes based on feedback
+3. Run tests to ensure everything works
+4. Commit your improvements: \`git commit -m "fix: address code review feedback - <brief description>"\`
+
+**CRITICAL - Output Format**:
+You MUST return ONLY the JSON object below after completing your improvements. Do NOT include any explanatory text, commentary, or markdown before or after the JSON. Return ONLY the JSON in this exact format:
+
+\`\`\`json
+{
+  "implementation_result": {
+    "feature_id": "...",
+    "branch_name": "${branchName}",
+    "files_modified": ["list", "of", "modified", "files"],
+    "commit_hash": "new commit hash after improvements",
+    "summary": "Brief description of improvements made based on code review feedback",
+    "tests_passed": true,
+    "pre_commit_passed": true,
+    "checklist_item_results": [
+      {
+        "checklist_item_id": "EXACT_CHECKLIST_ITEM_UUID_FROM_ID_FIELD",
+        "is_passed": true,
+        "value": "Result value based on item type",
+        "notes": "Optional notes about this checklist item"
+      }
+    ]
+  }
+}
+\`\`\`
+
+IMPORTANT: Return ONLY the JSON above. Do not add any text explaining what you did or how you improved the code. The JSON should be the complete and only content of your response.
+
+Begin improving your code implementation based on the code review feedback.`;
+};

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

@@ -0,0 +1,31 @@
+import { EdsgerConfig } from '../../types/index.js';
+export interface ChecklistItemVerificationResult {
+    checklist_item_id: string;
+    is_satisfied: boolean;
+    verification_status: 'confirmed' | 'rejected' | 'uncertain';
+    verification_reason: string;
+    concerns?: string[];
+    improvement_suggestions?: string[];
+}
+export interface ChecklistVerificationResult {
+    overall_status: 'passed' | 'failed' | 'partial';
+    summary: string;
+    confirmed_count: number;
+    rejected_count: number;
+    uncertain_count: number;
+    item_verifications: ChecklistItemVerificationResult[];
+    overall_suggestions?: string[];
+}
+export interface VerifyCodeImplementationOptions {
+    featureId: string;
+    branchName: string;
+    baseBranch: string;
+    featureName: string;
+    featureDescription?: string;
+    checklistContext: string;
+    verbose?: boolean;
+}
+/**
+ * Verify code implementation against checklist requirements by reviewing git diff
+ */
+export declare function verifyCodeImplementationCompliance(options: VerifyCodeImplementationOptions, config: EdsgerConfig): Promise<ChecklistVerificationResult>;

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