edsger 0.2.1 → 0.2.2

package/dist/{bug-fixing → phases/bug-fixing}/mcp-server.js

@@ -1,35 +1,6 @@
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code';
 import { z } from 'zod';
-// Helper function to make HTTP requests to the MCP server
-async function callMcpEndpoint(mcpServerUrl, mcpToken, method, params) {
-    try {
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method,
-                params,
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'MCP call failed');
-        }
-        return data.result;
-    }
-    catch (error) {
-        console.error(`MCP call failed for ${method}:`, error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
+import { callMcpEndpoint } from '../../api/mcp-client.js';
 // Create an SDK MCP server with custom tools for bug fixing
 export const createBugFixingMcpServer = (mcpServerUrl, mcpToken) => {
     return createSdkMcpServer({

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

@@ -0,0 +1,33 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface CodeImplementationOptions {
+    featureId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+    verbose?: boolean;
+    baseBranch?: string;
+}
+export interface CodeImplementationResult {
+    featureId: string;
+    branchName: string;
+    implementationSummary: string | null;
+    status: 'success' | 'error';
+    message: string;
+    filesModified?: string[];
+    commitHash?: string;
+    data?: {
+        checklist_results?: Array<{
+            checklist_id: string;
+            satisfied: boolean;
+            notes?: string;
+        }>;
+        checklist_item_results?: Array<{
+            checklist_item_id: string;
+            is_passed: boolean;
+            value?: any;
+            notes?: string;
+        }>;
+    };
+}
+export declare const implementFeatureCode: (options: CodeImplementationOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<CodeImplementationResult>;
+export declare const checkCodeImplementationRequirements: () => Promise<boolean>;

package/dist/{code-implementation → phases/code-implementation}/analyzer.js

@@ -1,5 +1,6 @@
 import { query } from '@anthropic-ai/claude-code';
-import { logInfo, logError } from '../logger.js';
+import { logInfo, logError } from '../../utils/logger.js';
+import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { fetchCodeImplementationContext, formatContextForPrompt, } from './context-fetcher.js';
 function userMessage(content) {
     return {
@@ -11,7 +12,7 @@ async function* prompt(implementationPrompt) {
     yield userMessage(implementationPrompt);
     await new Promise((res) => setTimeout(res, 10000));
 }
-export const implementFeatureCode = async (options, config) => {
+export const implementFeatureCode = async (options, config, checklistContext) => {
     const { featureId, mcpServerUrl, mcpToken, verbose, baseBranch = 'main', } = options;
     if (verbose) {
         logInfo(`Starting code implementation for feature ID: ${featureId}`);
@@ -24,13 +25,23 @@ export const implementFeatureCode = async (options, config) => {
             logInfo('Fetching code implementation context via MCP endpoints...');
         }
         const context = await fetchCodeImplementationContext(mcpServerUrl, mcpToken, featureId, verbose);
-        const systemPrompt = createSystemPrompt(config, baseBranch);
-        const implementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch);
+        const systemPrompt = createSystemPrompt(config, baseBranch, mcpServerUrl, mcpToken, featureId);
+        const implementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch, checklistContext, verbose);
         let lastAssistantResponse = '';
         let structuredImplementationResult = null;
         if (verbose) {
             logInfo('Starting Claude Code query with pre-fetched information...');
         }
+        // DEBUG: Log checklist context before query
+        console.log('=== DEBUG: Checklist Context Before Claude Query ===');
+        console.log('Has checklistContext:', !!checklistContext);
+        if (checklistContext) {
+            console.log('Number of checklists:', checklistContext.checklists.length);
+            const totalItems = checklistContext.checklists.reduce((sum, checklist) => sum + (checklist.items?.length || 0), 0);
+            console.log('Total checklist items:', totalItems);
+        }
+        console.log('Implementation prompt includes checklist:', implementationPrompt.includes('checklist'));
+        console.log('System prompt includes checklist:', systemPrompt.includes('checklist'));
         // Use Claude Code SDK without MCP servers - all info is pre-fetched
         for await (const message of query({
             prompt: prompt(implementationPrompt),
@@ -67,26 +78,85 @@ export const implementFeatureCode = async (options, config) => {
                         // Try to extract JSON from markdown code block or parse directly
                         const responseText = message.result || lastAssistantResponse;
                         let jsonResult = null;
+                        // DEBUG: Log response text details and checklist content
+                        console.log('=== DEBUG: Code Implementation Response Analysis ===');
+                        console.log('message.result exists:', !!message.result);
+                        console.log('lastAssistantResponse exists:', !!lastAssistantResponse);
+                        console.log('responseText length:', responseText.length);
+                        console.log('responseText first 200 chars:', JSON.stringify(responseText.substring(0, 200)));
+                        console.log('responseText last 200 chars:', JSON.stringify(responseText.substring(responseText.length - 200)));
+                        console.log('Contains ```json:', responseText.includes('```json'));
+                        console.log('Contains implementation_result:', responseText.includes('"implementation_result"'));
+                        console.log('=== DEBUG: Checklist Content in Response ===');
+                        console.log('Contains "checklist":', responseText.toLowerCase().includes('checklist'));
+                        console.log('Contains "checklist_item_results":', responseText.includes('checklist_item_results'));
+                        console.log('Contains checklist_item_id:', responseText.includes('checklist_item_id'));
+                        console.log('Contains is_passed:', responseText.includes('is_passed'));
+                        // Count checklist-related occurrences
+                        const checklistMatches = responseText.match(/checklist/gi) || [];
+                        const checklistItemMatches = responseText.match(/checklist_item/gi) || [];
+                        console.log('Total "checklist" mentions:', checklistMatches.length);
+                        console.log('Total "checklist_item" mentions:', checklistItemMatches.length);
                         // First try to extract JSON from markdown code block
                         const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        console.log('=== DEBUG: Markdown Block Match ===');
+                        console.log('jsonBlockMatch found:', !!jsonBlockMatch);
                         if (jsonBlockMatch) {
+                            console.log('Matched JSON length:', jsonBlockMatch[1].length);
+                            console.log('Matched JSON first 100 chars:', JSON.stringify(jsonBlockMatch[1].substring(0, 100)));
                             jsonResult = JSON.parse(jsonBlockMatch[1]);
                         }
                         else {
+                            console.log('=== DEBUG: Trying direct JSON parse ===');
                             // Try to parse the entire response as JSON
                             jsonResult = JSON.parse(responseText);
                         }
+                        console.log('=== DEBUG: Final Result Processing ===');
+                        console.log('jsonResult exists:', !!jsonResult);
+                        console.log('jsonResult has implementation_result:', !!(jsonResult && jsonResult.implementation_result));
                         if (jsonResult && jsonResult.implementation_result) {
+                            const implResult = jsonResult.implementation_result;
+                            console.log('=== DEBUG: Implementation Result Structure ===');
+                            console.log('Keys in implementation_result:', Object.keys(implResult));
+                            console.log('Has checklist_item_results field:', 'checklist_item_results' in implResult);
+                            console.log('checklist_item_results value type:', typeof implResult.checklist_item_results);
+                            console.log('checklist_item_results is array:', Array.isArray(implResult.checklist_item_results));
+                            if (implResult.checklist_item_results) {
+                                console.log('checklist_item_results length:', implResult.checklist_item_results.length);
+                                if (implResult.checklist_item_results.length > 0) {
+                                    console.log('First checklist item keys:', Object.keys(implResult.checklist_item_results[0]));
+                                    console.log('First checklist item sample:', JSON.stringify(implResult.checklist_item_results[0], null, 2));
+                                }
+                            }
+                            else {
+                                console.log('checklist_item_results is null/undefined/empty');
+                            }
                             structuredImplementationResult = jsonResult.implementation_result;
+                            console.log('Successfully extracted implementation_result');
                         }
                         else {
+                            console.log('ERROR: Invalid JSON structure - missing implementation_result');
                             throw new Error('Invalid JSON structure');
                         }
                     }
                     catch (error) {
+                        console.log('=== DEBUG: JSON Parsing Failed ===');
+                        console.log('Error type:', error instanceof SyntaxError
+                            ? 'SyntaxError'
+                            : error instanceof Error
+                                ? error.constructor.name
+                                : 'Unknown');
+                        console.log('Error message:', error instanceof Error ? error.message : String(error));
                         logError(`Failed to parse structured implementation result: ${error}`);
+                        console.log('=== DEBUG: Using Fallback Parsing ===');
                         // Fallback parsing
                         const parsedResult = parseImplementationResponse(message.result || lastAssistantResponse, featureId);
+                        console.log('Fallback parsed result:', {
+                            branchName: parsedResult.branchName,
+                            filesModifiedCount: parsedResult.filesModified?.length || 0,
+                            hasSummary: !!parsedResult.summary,
+                            commitHash: parsedResult.commitHash,
+                        });
                         structuredImplementationResult = {
                             branch_name: parsedResult.branchName,
                             files_modified: parsedResult.filesModified,
@@ -94,6 +164,7 @@ export const implementFeatureCode = async (options, config) => {
                             summary: parsedResult.summary || 'Implementation completed',
                             tests_passed: true,
                             pre_commit_passed: true,
+                            checklist_item_results: parsedResult.checklist_item_results || [],
                         };
                     }
                 }
@@ -104,10 +175,15 @@ export const implementFeatureCode = async (options, config) => {
                     }
                     // Try to parse results from the last assistant response
                     if (lastAssistantResponse) {
+                        console.log('=== DEBUG: Fallback for incomplete result ===');
+                        console.log('message.subtype:', message.subtype);
                         try {
                             const responseText = lastAssistantResponse;
                             let jsonResult = null;
+                            console.log('lastAssistantResponse length:', responseText.length);
+                            console.log('lastAssistantResponse first 200 chars:', JSON.stringify(responseText.substring(0, 200)));
                             const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                            console.log('jsonBlockMatch in fallback found:', !!jsonBlockMatch);
                             if (jsonBlockMatch) {
                                 jsonResult = JSON.parse(jsonBlockMatch[1]);
                                 if (jsonResult && jsonResult.implementation_result) {
@@ -124,21 +200,25 @@ export const implementFeatureCode = async (options, config) => {
             }
         }
         if (structuredImplementationResult) {
-            const { branch_name, files_modified, commit_hash, summary } = structuredImplementationResult;
+            const { branch_name, files_modified, commit_hash, summary, checklist_results, checklist_item_results, } = structuredImplementationResult;
             return {
                 featureId,
-                branchName: branch_name || `feature/${featureId}`,
+                branchName: branch_name || `dev/${featureId}`,
                 implementationSummary: summary || 'Implementation completed',
                 status: 'success',
                 message: 'Code implementation completed successfully',
                 filesModified: files_modified || [],
                 commitHash: commit_hash || '',
+                data: {
+                    checklist_results,
+                    checklist_item_results,
+                },
             };
         }
         else {
             return {
                 featureId,
-                branchName: `feature/${featureId}`,
+                branchName: `dev/${featureId}`,
                 implementationSummary: null,
                 status: 'error',
                 message: 'Code implementation failed or incomplete',
@@ -149,14 +229,31 @@ export const implementFeatureCode = async (options, config) => {
         logError(`Code implementation failed: ${error instanceof Error ? error.message : String(error)}`);
         return {
             featureId,
-            branchName: `feature/${featureId}`,
+            branchName: `dev/${featureId}`,
             implementationSummary: null,
             status: 'error',
             message: `Implementation failed: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
 };
-const createSystemPrompt = (_config, baseBranch) => {
+const createSystemPrompt = (_config, baseBranch, mcpServerUrl, mcpToken, featureId) => {
+    let mcpInstructions = '';
+    if (mcpServerUrl && mcpToken && featureId) {
+        mcpInstructions = `
+
+**MANDATORY Checklist Compliance**:
+If you are provided with checklists in the context, you MUST satisfy ALL of them during your implementation work. Checklists are mandatory requirements that define quality standards and cannot be ignored or skipped.
+
+- Review each checklist carefully and ensure your implementation addresses every requirement
+- You MUST include ALL provided checklist item IDs in the "checklist_item_results" field of your JSON response
+- CRITICAL: Use the exact UUID from the "ID:" field in each checklist ITEM, NOT the item title or description
+- Set "is_passed": true for each checklist item you have completed successfully
+- Provide appropriate "value" based on the item type (boolean: true/false, text: descriptive text, number: numeric value)
+- If you cannot satisfy a checklist item requirement, set "is_passed": false and explain why in the "notes" field
+- The system will validate that all checklists have been addressed - missing checklists will cause the pipeline to fail
+
+CRITICAL: Checklists are not optional suggestions - they are mandatory quality gates that must be satisfied.`;
+    }
     return `You are an expert full-stack developer implementing features based on specifications. Your task is to implement complete, production-ready code based on feature requirements, user stories, test cases, and technical design.
 
 **Your Role**: Implement complete, working features based on provided specifications and requirements.
@@ -167,7 +264,7 @@ const createSystemPrompt = (_config, baseBranch) => {
 - Read: Examine existing code, configuration, and documentation files
 - Edit: Modify existing files
 - Write: Create new files
-- TodoWrite: Track implementation tasks (use proactively)
+- TodoWrite: Track implementation tasks (use proactively)${mcpInstructions}
 
 **CRITICAL WORKFLOW - YOU MUST FOLLOW THESE STEPS IN ORDER**:
 
@@ -231,18 +328,77 @@ You MUST end your response with a JSON object containing the implementation resu
     "commit_hash": "abc123...",
     "summary": "Brief description of what was implemented",
     "tests_passed": true,
-    "pre_commit_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 (boolean, text, number, etc.)",
+        "notes": "Optional notes about this specific checklist item"
+      }
+    ]
   }
 }
 \`\`\`
 
+MANDATORY: If checklists are provided in the context, you MUST include checklist_item_results for ALL checklist items. Every checklist item ID must be addressed - either passed or with explanation in notes why it cannot be satisfied. Missing any checklist item will cause the pipeline to fail.
+
+IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the items list - use these exact UUIDs as checklist_item_id values. Do NOT use the item title or description as the checklist_item_id.
+
 Remember: Quality over speed. It's better to implement correctly than to rush and create bugs.`;
 };
-const createImplementationPromptWithContext = (featureId, context, baseBranch) => {
+const createImplementationPromptWithContext = (featureId, context, baseBranch, checklistContext, verbose) => {
     const contextInfo = formatContextForPrompt(context);
+    // Add checklist context to the implementation prompt
+    let finalContextInfo = contextInfo;
+    let checklistInstructions = '';
+    if (checklistContext && checklistContext.checklists.length > 0) {
+        const checklistInfo = formatChecklistsForContext(checklistContext);
+        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        // DEBUG: Log checklist context details
+        console.log('=== DEBUG: Checklist Context for Code Implementation ===');
+        console.log('Number of checklists:', checklistContext.checklists.length);
+        console.log('Checklist info length:', checklistInfo.length);
+        console.log('Checklist info preview:', checklistInfo.substring(0, 300));
+        checklistContext.checklists.forEach((checklist, index) => {
+            console.log(`Checklist ${index + 1}:`, {
+                id: checklist.id,
+                name: checklist.name,
+                phase: checklist.phase,
+                role: checklist.role,
+                itemCount: checklist.items?.length || 0,
+            });
+            if (checklist.items) {
+                checklist.items.forEach((item, itemIndex) => {
+                    console.log(`  Item ${itemIndex + 1}:`, {
+                        id: item.id,
+                        title: item.title?.substring(0, 50) || 'No title',
+                        description: item.description?.substring(0, 50) || 'No description',
+                    });
+                });
+            }
+        });
+        // Add specific instructions for creating checklist results
+        checklistInstructions = `
+
+## MANDATORY Checklist Compliance
+
+**CRITICAL**: You MUST address ALL checklists provided in the context above. Checklists are mandatory quality requirements that cannot be ignored.
+
+- Review each checklist carefully during your implementation
+- Ensure your code and processes satisfy every checklist requirement
+- Include ALL checklist item IDs in your final JSON response under "checklist_item_results" (use the exact UUID from "ID:" field in items list)
+- Set "is_passed": true for completed checklist items, or explain in "notes" why a requirement cannot be met
+- Missing any checklist will cause the entire pipeline to fail
+
+Remember: Checklists are not suggestions - they are mandatory quality gates.`;
+        if (verbose) {
+            logInfo(`Added ${checklistContext.checklists.length} checklists to implementation context`);
+        }
+    }
     return `Implement the complete feature for feature ID: ${featureId}
 
-${contextInfo}
+${finalContextInfo}
 
 ## Implementation Instructions
 
@@ -287,6 +443,8 @@ Follow this systematic approach:
 - Maintain existing code quality and patterns
 - Never skip pre-commit checks - always fix the issues
 
+${checklistInstructions}
+
 Begin by creating a feature branch and analyzing the codebase structure.`;
 };
 const parseImplementationResponse = (response, featureId) => {
@@ -305,6 +463,7 @@ const parseImplementationResponse = (response, featureId) => {
                     filesModified: result.files_modified || [],
                     commitHash: result.commit_hash || '',
                     summary: result.summary || '',
+                    checklist_item_results: result.checklist_item_results || [],
                 };
             }
         }
@@ -313,7 +472,7 @@ const parseImplementationResponse = (response, featureId) => {
         const filesMatch = response.match(/files?[:\s]+([^\n]+)/i);
         const commitMatch = response.match(/commit[:\s]+([a-f0-9]{7,})/i);
         return {
-            branchName: branchMatch?.[1] || `feature/${featureId}`,
+            branchName: branchMatch?.[1] || `dev/${featureId}`,
             filesModified: filesMatch
                 ? filesMatch[1].split(/[,\s]+/).filter((f) => f)
                 : [],
@@ -324,7 +483,7 @@ const parseImplementationResponse = (response, featureId) => {
     catch (error) {
         console.log('Response parsing failed:', error);
         return {
-            branchName: `feature/${featureId}`,
+            branchName: `dev/${featureId}`,
             filesModified: [],
             commitHash: '',
             summary: 'Implementation completed',

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

@@ -0,0 +1,17 @@
+import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
+import { type ProductInfo } from '../../api/products.js';
+export interface CodeImplementationContext {
+    feature: FeatureInfo;
+    product: ProductInfo;
+    user_stories: UserStory[];
+    test_cases: TestCase[];
+    technical_design?: string;
+}
+/**
+ * Fetch all code implementation context information via MCP endpoints
+ */
+export declare function fetchCodeImplementationContext(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<CodeImplementationContext>;
+/**
+ * Format the context into a readable string for Claude Code
+ */
+export declare function formatContextForPrompt(context: CodeImplementationContext): string;

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(mcpServerUrl, mcpToken, 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(mcpServerUrl, mcpToken, featureId, verbose),
+            getUserStories(mcpServerUrl, mcpToken, featureId, verbose),
+            getTestCases(mcpServerUrl, mcpToken, featureId, verbose),
+        ]);
+        const product = await getProduct(mcpServerUrl, mcpToken, 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/{code-implementation → phases/code-implementation}/mcp-server.js

@@ -1,35 +1,6 @@
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code';
 import { z } from 'zod';
-// Helper function to make HTTP requests to the MCP server
-async function callMcpEndpoint(mcpServerUrl, mcpToken, method, params) {
-    try {
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method,
-                params,
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'MCP call failed');
-        }
-        return data.result;
-    }
-    catch (error) {
-        console.error(`MCP call failed for ${method}:`, error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
+import { callMcpEndpoint } from '../../api/mcp-client.js';
 // Create an SDK MCP server with custom tools for code implementation
 export const createCodeImplementationMcpServer = (mcpServerUrl, mcpToken) => {
     return createSdkMcpServer({

package/dist/{code-review → phases/code-review}/reviewer.d.ts

@@ -1,3 +1,3 @@
-import { EdsgerConfig, ReviewResult } from '../types.js';
+import { EdsgerConfig, ReviewResult } from '../../types/index.js';
 export declare const reviewWithClaudeSDK: (config: EdsgerConfig, staged?: boolean, filePatterns?: string[]) => Promise<ReviewResult[]>;
 export declare const checkClaudeCodeSDK: () => Promise<boolean>;

package/dist/{feature-analysis → phases/feature-analysis}/analyzer.d.ts

@@ -1,9 +1,10 @@
-import { EdsgerConfig, FeatureAnalysisResult } from '../types.js';
+import { EdsgerConfig, FeatureAnalysisResult } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
 export interface FeatureAnalysisOptions {
     featureId: string;
     mcpServerUrl: string;
     mcpToken: string;
     verbose?: boolean;
 }
-export declare const analyzeFeatureWithMCP: (options: FeatureAnalysisOptions, config: EdsgerConfig) => Promise<FeatureAnalysisResult>;
+export declare const analyzeFeatureWithMCP: (options: FeatureAnalysisOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<FeatureAnalysisResult>;
 export declare const checkFeatureAnalysisRequirements: () => Promise<boolean>;