edsger 0.2.0 → 0.2.2

package/dist/phases/technical-design/analyzer.js

@@ -0,0 +1,418 @@
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { saveTechnicalDesignViaHttp } from './http-fallback.js';
+import { fetchTechnicalDesignContext, } from './context-fetcher.js';
+import { updateTechnicalDesign } from '../../api/features/index.js';
+import { formatTechnicalDesignContext } from '../../prompts/formatters.js';
+import { createTechnicalDesignSystemPrompt, createTechnicalDesignPromptWithContext, } from '../../prompts/technical-design.js';
+import { formatChecklistsForContext, } from '../../services/checklist.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(analysisPrompt) {
+    yield userMessage(analysisPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+export const generateTechnicalDesign = async (options, config, checklistContext) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting technical design generation for feature ID: ${featureId}`);
+        logInfo(`Using MCP server: ${mcpServerUrl}`);
+    }
+    try {
+        // Fetch all required context information via MCP endpoints
+        if (verbose) {
+            logInfo('Fetching technical design context via MCP endpoints...');
+        }
+        const context = await fetchTechnicalDesignContext(mcpServerUrl, mcpToken, featureId, verbose);
+        const systemPrompt = createTechnicalDesignSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
+        const contextInfo = formatTechnicalDesignContext(context);
+        // Add checklist context to the design prompt
+        let finalContextInfo = contextInfo;
+        if (checklistContext && checklistContext.checklists.length > 0) {
+            const checklistInfo = formatChecklistsForContext(checklistContext);
+            finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+            if (verbose) {
+                logInfo(`Added ${checklistContext.checklists.length} checklists to design context`);
+            }
+        }
+        const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo);
+        let lastAssistantResponse = '';
+        let structuredDesignResult = null;
+        if (verbose) {
+            logInfo('Starting Claude Code query with pre-fetched information...');
+        }
+        // Use Claude Code SDK without MCP servers - all info is pre-fetched
+        for await (const message of query({
+            prompt: prompt(designPrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 1000,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`Received message type: ${message.type}`);
+            }
+            // Stream the technical design generation 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') {
+                    logInfo('\n🎨 Technical design generation completed, parsing results...');
+                    try {
+                        // Try to extract JSON from markdown code block or parse directly
+                        const responseText = message.result || lastAssistantResponse;
+                        let jsonResult = null;
+                        // DEBUG: Log response text details
+                        console.log('=== DEBUG: Response Text 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 technical_design_result:', responseText.includes('"technical_design_result"'));
+                        // 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: JSON Object Search ===');
+                            // Try to find JSON object containing "technical_design_result"
+                            const lines = responseText.split('\n');
+                            let jsonStartIndex = -1;
+                            console.log('Total lines:', lines.length);
+                            console.log('Lines preview:', lines
+                                .slice(0, 10)
+                                .map((line, i) => `${i}: ${JSON.stringify(line.substring(0, 50))}`));
+                            // Find the line that contains the start of a JSON object with "technical_design_result"
+                            for (let i = 0; i < lines.length; i++) {
+                                const line = lines[i].trim();
+                                if (line.startsWith('{') &&
+                                    responseText.includes('"technical_design_result"')) {
+                                    console.log(`Found { at line ${i}: ${JSON.stringify(line)}`);
+                                    const fromThisLine = lines.slice(i).join('\n');
+                                    if (fromThisLine.includes('"technical_design_result"')) {
+                                        jsonStartIndex = responseText.indexOf(lines[i]);
+                                        console.log(`JSON start found at line ${i}, responseText index: ${jsonStartIndex}`);
+                                        break;
+                                    }
+                                }
+                            }
+                            if (jsonStartIndex !== -1) {
+                                // Find the complete JSON object starting from this position
+                                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);
+                                console.log('=== DEBUG: JSON Extraction ===');
+                                console.log('JSON start index:', jsonStartIndex);
+                                console.log('JSON end index:', endIndex);
+                                console.log('Extracted JSON length:', jsonStr.length);
+                                console.log('Extracted JSON first 100 chars:', JSON.stringify(jsonStr.substring(0, 100)));
+                                console.log('Extracted JSON last 100 chars:', JSON.stringify(jsonStr.substring(jsonStr.length - 100)));
+                                try {
+                                    jsonResult = JSON.parse(jsonStr);
+                                    console.log('JSON parsing succeeded!');
+                                }
+                                catch (parseError) {
+                                    console.log('Failed to parse extracted JSON:', parseError);
+                                    console.log('Extracted JSON string:', jsonStr.substring(0, 200) + '...');
+                                    console.log('=== DEBUG: Fallback to full response ===');
+                                    console.log('Attempting to parse entire responseText as JSON');
+                                    // Try to parse the entire response as JSON as fallback
+                                    jsonResult = JSON.parse(responseText);
+                                }
+                            }
+                            else {
+                                console.log('=== DEBUG: No JSON start found ===');
+                                console.log('Falling back to parse entire responseText as JSON');
+                                // 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 technical_design_result:', !!(jsonResult && jsonResult.technical_design_result));
+                        if (jsonResult && jsonResult.technical_design_result) {
+                            console.log('checklist_item_results in parsed JSON:', !!jsonResult.technical_design_result.checklist_item_results);
+                            if (jsonResult.technical_design_result.checklist_item_results) {
+                                console.log('checklist_item_results length:', jsonResult.technical_design_result.checklist_item_results
+                                    .length);
+                            }
+                            structuredDesignResult = jsonResult.technical_design_result;
+                        }
+                        else {
+                            throw new Error('Invalid JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse structured design result: ${error}`);
+                        // Extract technical design from response if JSON parsing fails
+                        const extractedDesign = extractTechnicalDesignFromResponse(message.result || lastAssistantResponse);
+                        structuredDesignResult = {
+                            status: extractedDesign ? 'success' : 'error',
+                            technical_design: extractedDesign,
+                            summary: extractedDesign
+                                ? 'Technical design generated successfully'
+                                : 'Failed to generate technical design',
+                        };
+                    }
+                }
+                else {
+                    logError(`\n⚠️  Technical design generation incomplete: ${message.subtype}`);
+                    if (message.subtype === 'error_max_turns') {
+                        logError('💡 Try increasing timeout or reducing complexity');
+                    }
+                    // Try to parse results from the last assistant response
+                    if (lastAssistantResponse) {
+                        try {
+                            const responseText = lastAssistantResponse;
+                            let jsonResult = null;
+                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                            if (jsonBlockMatch) {
+                                jsonResult = JSON.parse(jsonBlockMatch[1]);
+                                if (jsonResult && jsonResult.technical_design_result) {
+                                    structuredDesignResult = jsonResult.technical_design_result;
+                                }
+                            }
+                            else {
+                                // Try to find JSON object containing "technical_design_result"
+                                const lines = responseText.split('\n');
+                                let jsonStartIndex = -1;
+                                // Find the line that contains the start of a JSON object with "technical_design_result"
+                                for (let i = 0; i < lines.length; i++) {
+                                    const line = lines[i].trim();
+                                    if (line.startsWith('{') &&
+                                        responseText.includes('"technical_design_result"')) {
+                                        const fromThisLine = lines.slice(i).join('\n');
+                                        if (fromThisLine.includes('"technical_design_result"')) {
+                                            jsonStartIndex = responseText.indexOf(lines[i]);
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (jsonStartIndex !== -1) {
+                                    // Find the complete JSON object starting from this position
+                                    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);
+                                        if (jsonResult && jsonResult.technical_design_result) {
+                                            structuredDesignResult =
+                                                jsonResult.technical_design_result;
+                                        }
+                                    }
+                                    catch (parseError) {
+                                        logError(`Failed to parse extracted JSON: ${parseError}`);
+                                    }
+                                }
+                                if (!structuredDesignResult) {
+                                    const extractedDesign = extractTechnicalDesignFromResponse(lastAssistantResponse);
+                                    if (extractedDesign) {
+                                        structuredDesignResult = {
+                                            status: 'success',
+                                            technical_design: extractedDesign,
+                                            summary: 'Technical design generated successfully',
+                                        };
+                                    }
+                                }
+                            }
+                        }
+                        catch (error) {
+                            logError(`Failed to parse assistant response: ${error}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Save the technical design if we have it
+        if (structuredDesignResult?.technical_design) {
+            if (verbose) {
+                logInfo('Saving technical design...');
+            }
+            const designSaved = await updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, structuredDesignResult.technical_design, verbose);
+            // Try HTTP fallback if direct update failed
+            if (!designSaved) {
+                if (verbose) {
+                    logInfo('Direct update failed, trying HTTP fallback...');
+                }
+                const fallbackSaved = await saveTechnicalDesignViaHttp({
+                    mcpServerUrl,
+                    mcpToken,
+                    featureId,
+                    technicalDesign: structuredDesignResult.technical_design,
+                    verbose,
+                });
+                if (!fallbackSaved && verbose) {
+                    logError('⚠️  Both direct update and HTTP fallback failed');
+                }
+                return {
+                    featureId,
+                    technicalDesign: structuredDesignResult.technical_design,
+                    status: fallbackSaved ? 'success' : 'error',
+                    summary: fallbackSaved
+                        ? 'Technical design generated and saved via HTTP fallback'
+                        : 'Technical design generated but failed to save',
+                    savedViaHttp: fallbackSaved,
+                    data: {
+                        checklist_item_results: structuredDesignResult.checklist_item_results || [],
+                    },
+                };
+            }
+            return {
+                featureId,
+                technicalDesign: structuredDesignResult.technical_design,
+                status: 'success',
+                summary: 'Technical design generated and saved successfully',
+                data: {
+                    checklist_item_results: structuredDesignResult.checklist_item_results || [],
+                },
+            };
+        }
+        return {
+            featureId,
+            technicalDesign: null,
+            status: 'error',
+            summary: 'No technical design was generated',
+        };
+    }
+    catch (error) {
+        logError(`Technical design generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            featureId,
+            technicalDesign: null,
+            status: 'error',
+            summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const extractTechnicalDesignFromResponse = (response) => {
+    // Try to extract technical design content from the response
+    // Look for markdown sections that contain technical design
+    const lines = response.split('\n');
+    let inTechnicalDesign = false;
+    const technicalDesignLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].toLowerCase();
+        // Look for technical design section headers
+        if (line.includes('technical design') ||
+            line.includes('architecture') ||
+            line.includes('# design') ||
+            line.includes('## technical')) {
+            inTechnicalDesign = true;
+            technicalDesignLines.push(lines[i]);
+            continue;
+        }
+        if (inTechnicalDesign) {
+            // Continue until we hit another major section or JSON
+            if (line.startsWith('{') && line.includes('"technical_design_result"')) {
+                break;
+            }
+            technicalDesignLines.push(lines[i]);
+        }
+    }
+    if (technicalDesignLines.length > 0) {
+        return technicalDesignLines.join('\n').trim();
+    }
+    // Ultimate fallback: return the whole response if it seems to contain design content
+    if (response.length > 100 &&
+        (response.toLowerCase().includes('architecture') ||
+            response.toLowerCase().includes('component') ||
+            response.toLowerCase().includes('database'))) {
+        return response.trim();
+    }
+    return null;
+};
+export const checkTechnicalDesignRequirements = async () => {
+    try {
+        // Check if Claude Code SDK is available
+        const claudeCode = await import('@anthropic-ai/claude-code');
+        return claudeCode && typeof claudeCode.query === 'function';
+    }
+    catch (error) {
+        console.log('Technical design requirements check failed:', error instanceof Error ? error.message : error);
+        return false;
+    }
+};

package/dist/phases/technical-design/context-fetcher.d.ts

@@ -0,0 +1,12 @@
+import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
+import { type ProductInfo } from '../../api/products.js';
+export interface TechnicalDesignContext {
+    feature: FeatureInfo;
+    product: ProductInfo;
+    user_stories: UserStory[];
+    test_cases: TestCase[];
+}
+/**
+ * Fetch all technical design context information via MCP endpoints
+ */
+export declare function fetchTechnicalDesignContext(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<TechnicalDesignContext>;

package/dist/phases/technical-design/context-fetcher.js

@@ -0,0 +1,39 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature, getUserStories, getTestCases, } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+/**
+ * Fetch all technical design context information via MCP endpoints
+ */
+export async function fetchTechnicalDesignContext(mcpServerUrl, mcpToken, featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching complete technical design 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(`✅ Technical design context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   User Stories: ${user_stories.length}`);
+            logInfo(`   Test Cases: ${test_cases.length} (${test_cases.filter((tc) => tc.is_critical).length} critical)`);
+            logInfo(`   Existing Technical Design: ${feature.technical_design ? 'Yes' : 'No'}`);
+        }
+        return {
+            feature,
+            product,
+            user_stories,
+            test_cases,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch technical design context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}

package/dist/{technical-design → phases/technical-design}/http-fallback.js

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../logger.js';
+import { logInfo, logError } from '../../utils/logger.js';
 /**
  * Save technical design via HTTP as a fallback when MCP server fails
  */

package/dist/{technical-design → phases/technical-design}/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 technical design generation
 export const createTechnicalDesignMcpServer = (mcpServerUrl, mcpToken) => {
     return createSdkMcpServer({

package/dist/prompts/bug-fixing.d.ts

@@ -0,0 +1,2 @@
+import { EdsgerConfig } from '../types/index.js';
+export declare const createBugFixingSystemPrompt: (_config: EdsgerConfig) => string;

package/dist/prompts/bug-fixing.js

@@ -0,0 +1,63 @@
+export const createBugFixingSystemPrompt = (_config) => {
+    return `You are an expert software engineer specializing in fixing bugs and test failures. Your goal is to analyze test failures and fix the underlying issues in the code.
+
+**Your Role**: Fix bugs and test failures while maintaining existing functionality and code quality.
+
+**Available Tools**:
+- Bash: Run commands, tests, and git operations
+- Glob: Find files and understand project structure
+- Read: Examine existing code and files
+- Edit: Modify existing files to fix issues
+- Write: Create new files if absolutely necessary
+- TodoWrite: Track bug fixing tasks (use proactively)
+
+**Bug Fixing Process**:
+1. **Git Pull Rebase**: Ensure main branch is up to date: git pull origin main --rebase
+2. **Analyze Failures**: Study test error messages and stack traces to identify root causes
+3. **Examine Code**: Read the relevant code files to understand current implementation
+4. **Fix Issues**: Make minimal, targeted changes to resolve the failures
+5. **Test Fixes**: Run tests to verify fixes work and don't break other functionality
+6. **Validate**: Ensure all critical test cases pass
+
+**Important Guidelines**:
+- All feature context, user stories, test cases, and test reports are provided in the prompt
+- Focus ONLY on fixing the reported test failures
+- Do not refactor or optimize unrelated code
+- Preserve existing functionality and patterns
+- Make minimal necessary changes
+- Test your fixes thoroughly
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the bug fix results in this EXACT format:
+
+\`\`\`json
+{
+  "fix_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "attempt_number": 1,
+    "summary": "Brief description of what was fixed",
+    "files_modified": ["file1.ts", "file2.tsx"],
+    "tests_passed": true,
+    "fixes_applied": [
+      {
+        "issue": "Description of the issue",
+        "fix": "Description of how it was fixed",
+        "file": "path/to/file.ts"
+      }
+    ],
+    "remaining_issues": ["Any issues that could not be resolved"],
+    "recommendations": "Additional recommendations for the development team"
+  }
+}
+\`\`\`
+
+**Quality Guidelines**:
+- Focus on minimal, surgical fixes that address specific test failures
+- Preserve existing code patterns and architecture
+- Ensure backward compatibility
+- Add appropriate error handling where missing
+- Update documentation if interfaces change
+- Test thoroughly before considering issues resolved
+
+Focus on systematic debugging and targeted fixes based on the provided test failure information.`;
+};

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

@@ -0,0 +1,3 @@
+import { EdsgerConfig } from '../types/index.js';
+export declare const createCodeImplementationSystemPrompt: (_config: EdsgerConfig, baseBranch: string) => string;
+export declare const createCodeImplementationPromptWithContext: (featureId: string, contextInfo: string, baseBranch: string) => string;