edsger 0.2.0 → 0.2.2

package/dist/{functional-testing → phases/functional-testing}/test-report-creator.js

@@ -1,10 +1,10 @@
-import { logInfo, logError } from '../logger.js';
+import { logInfo, logError } from '../../utils/logger.js';
 /**
  * Create a test report via MCP endpoint
  * Uses structured data generated by Claude Code
  */
 export async function createTestReport(options) {
-    const { mcpServerUrl, mcpToken, featureId, testReportData, verbose } = options;
+    const { mcpServerUrl, mcpToken, featureId, testReportData, testResults, verbose, } = options;
     if (verbose) {
         logInfo(`Creating test report for feature: ${featureId}`);
     }
@@ -53,6 +53,19 @@ export async function createTestReport(options) {
                 if (verbose) {
                     logInfo(`✅ Test report created via MCP: ${testReport.id}`);
                 }
+                // Create test report results if provided
+                if (testResults && testResults.length > 0) {
+                    const resultsResponse = await createTestReportResults({
+                        mcpServerUrl,
+                        mcpToken,
+                        testReportId: testReport.id,
+                        testResults,
+                        verbose,
+                    });
+                    if (verbose && resultsResponse.success) {
+                        logInfo(`✅ Created ${resultsResponse.resultsCreated} test report results`);
+                    }
+                }
                 return {
                     success: true,
                     testReport,
@@ -65,7 +78,7 @@ export async function createTestReport(options) {
             logInfo('Claude Code MCP call may have failed, manually calling MCP endpoint...');
         }
         // Manual fallback: Call MCP endpoint with the structured data
-        const fallbackResult = await manualMcpTestReportCreation(mcpServerUrl, mcpToken, featureId, structuredReport, verbose);
+        const fallbackResult = await manualMcpTestReportCreation(mcpServerUrl, mcpToken, featureId, structuredReport, testResults, verbose);
         return fallbackResult;
     }
     catch (error) {
@@ -74,14 +87,70 @@ export async function createTestReport(options) {
             logError(`Test report creation failed: ${errorMessage}`);
         }
         // Manual fallback on any error
-        return manualMcpTestReportCreation(mcpServerUrl, mcpToken, featureId, structuredReport, verbose);
+        return manualMcpTestReportCreation(mcpServerUrl, mcpToken, featureId, structuredReport, testResults, verbose);
     }
 }
 /**
  * Manual fallback: Call MCP endpoint with structured data
  * This is used when Claude Code fails to call MCP directly
  */
-async function manualMcpTestReportCreation(mcpServerUrl, mcpToken, featureId, structuredReport, verbose) {
+/**
+ * Create test report results via MCP endpoint
+ */
+export async function createTestReportResults(options) {
+    const { mcpServerUrl, mcpToken, testReportId, testResults, verbose } = options;
+    if (verbose) {
+        logInfo(`Creating ${testResults.length} test report results for report: ${testReportId}`);
+    }
+    try {
+        const response = await fetch(`${mcpServerUrl}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${mcpToken}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'test_report_results/create',
+                params: {
+                    test_report_id: testReportId,
+                    test_results: testResults,
+                },
+                id: Math.random().toString(36).substring(7),
+            }),
+        });
+        const data = await response.json();
+        if (response.ok && !data.error && data.result) {
+            const resultData = data.result;
+            if (verbose) {
+                logInfo(`✅ Created ${resultData.results_created} test report results`);
+            }
+            return {
+                success: true,
+                resultsCreated: resultData.results_created,
+            };
+        }
+        const errorMessage = data.error?.message || 'Failed to create test report results';
+        if (verbose) {
+            logError(`Test report results creation failed: ${errorMessage}`);
+        }
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (verbose) {
+            logError(`Test report results creation failed: ${errorMessage}`);
+        }
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+async function manualMcpTestReportCreation(mcpServerUrl, mcpToken, featureId, structuredReport, testResults, verbose) {
     if (verbose) {
         logInfo('Manually calling MCP test_reports/create endpoint with structured data');
     }
@@ -114,6 +183,19 @@ async function manualMcpTestReportCreation(mcpServerUrl, mcpToken, featureId, st
             if (verbose) {
                 logInfo(`✅ Test report created manually via MCP: ${testReport.id}`);
             }
+            // Create test report results if provided
+            if (testResults && testResults.length > 0) {
+                const resultsResponse = await createTestReportResults({
+                    mcpServerUrl,
+                    mcpToken,
+                    testReportId: testReport.id,
+                    testResults,
+                    verbose,
+                });
+                if (verbose && resultsResponse.success) {
+                    logInfo(`✅ Created ${resultsResponse.resultsCreated} test report results`);
+                }
+            }
             return {
                 success: true,
                 testReport,

package/dist/phases/functional-testing/test-retry-handler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Test retry and bug fixing handler for pipeline execution
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { PipelinePhaseOptions, PipelineResult } from '../../types/pipeline.js';
+export declare const MAX_FIX_ATTEMPTS = 3;
+export interface TestRetryOptions {
+    options: PipelinePhaseOptions;
+    config: EdsgerConfig;
+    results: PipelineResult[];
+    verbose?: boolean;
+}
+/**
+ * Handle test failures with automatic bug fixing and retry
+ */
+export declare function handleTestFailuresWithRetry({ options, config, results, verbose, }: TestRetryOptions): Promise<PipelineResult>;

package/dist/phases/functional-testing/test-retry-handler.js

@@ -0,0 +1,75 @@
+/**
+ * Test retry and bug fixing handler for pipeline execution
+ */
+import { fixTestFailures, checkBugFixingRequirements, } from '../bug-fixing/analyzer.js';
+import { runFunctionalTestingPhase } from '../../workflow-runner/executors/phase-executor.js';
+import { updateFeatureStatusForPhase } from '../../api/features/index.js';
+import { logPhaseResult } from '../../utils/pipeline-logger.js';
+export const MAX_FIX_ATTEMPTS = 3;
+/**
+ * Handle test failures with automatic bug fixing and retry
+ */
+export async function handleTestFailuresWithRetry({ options, config, results, verbose, }) {
+    let testingResult;
+    let fixAttempt = 0;
+    do {
+        // Run functional testing
+        testingResult = await runFunctionalTestingPhase(options, config);
+        results.push(logPhaseResult(testingResult, verbose));
+        // If tests failed and we haven't exceeded max attempts, try to fix
+        if (testingResult.status === 'error' && fixAttempt < MAX_FIX_ATTEMPTS) {
+            fixAttempt++;
+            if (verbose) {
+                console.log(`🔧 Tests failed. Attempting to fix bugs (Attempt ${fixAttempt}/${MAX_FIX_ATTEMPTS})...`);
+            }
+            // Check if bug fixing requirements are met
+            const hasBugFixingReqs = await checkBugFixingRequirements();
+            if (!hasBugFixingReqs) {
+                if (verbose) {
+                    console.log('⚠️ Bug fixing requirements not met. Skipping automatic fixes.');
+                }
+                break;
+            }
+            // Extract test errors from the testing result
+            const testErrors = testingResult.data?.testResult || testingResult.message;
+            // Run bug fixing
+            const fixResult = await fixTestFailures({
+                featureId: options.featureId,
+                mcpServerUrl: options.mcpServerUrl,
+                mcpToken: options.mcpToken,
+                testErrors,
+                attemptNumber: fixAttempt,
+                verbose,
+            }, config);
+            if (fixResult.status === 'success') {
+                if (verbose) {
+                    console.log(`✅ Bug fixes applied. Re-running tests...`);
+                    if (fixResult.filesFixed && fixResult.filesFixed.length > 0) {
+                        console.log(`   Files fixed: ${fixResult.filesFixed.join(', ')}`);
+                    }
+                }
+                // Remove the previous failed test result from results
+                results.pop();
+                // Update status to indicate we're retrying tests
+                await updateFeatureStatusForPhase({ mcpServerUrl: options.mcpServerUrl, mcpToken: options.mcpToken }, options.featureId, 'functional-testing', verbose);
+            }
+            else {
+                if (verbose) {
+                    console.log(`❌ Bug fixing failed: ${fixResult.message}`);
+                }
+                break;
+            }
+        }
+        else {
+            // Tests passed or max attempts reached
+            break;
+        }
+    } while (fixAttempt <= MAX_FIX_ATTEMPTS);
+    // Log if max attempts reached
+    if (testingResult.status === 'error' &&
+        fixAttempt >= MAX_FIX_ATTEMPTS &&
+        verbose) {
+        console.log(`⚠️ Maximum fix attempts (${MAX_FIX_ATTEMPTS}) reached. Tests still failing.`);
+    }
+    return testingResult;
+}

package/dist/{pull-request → phases/pull-request}/creator.js

@@ -91,7 +91,7 @@ export async function createPullRequest(config, feature) {
         const octokit = new Octokit({
             auth: githubToken,
         });
-        // Get current branch
+        // Get current branch (should be dev/feature-id)
         const currentBranch = getCurrentBranch();
         if (verbose) {
             console.log(`🔍 Current branch: ${currentBranch}`);
@@ -103,22 +103,63 @@ export async function createPullRequest(config, feature) {
                 error: `Cannot create PR: already on ${baseBranch} branch`,
             };
         }
-        // Push current branch to remote
-        pushBranch(currentBranch, verbose);
+        // Extract feature ID from current branch (dev/feature-id)
+        let targetBranch = baseBranch;
+        if (currentBranch.startsWith('dev/')) {
+            const featureId = currentBranch.replace('dev/', '');
+            targetBranch = `feat/${featureId}`;
+            // Create the feat/ branch from current dev/ branch
+            if (verbose) {
+                console.log(`📝 Creating target branch: ${targetBranch} from ${currentBranch}`);
+            }
+            try {
+                // Push current branch to remote first
+                pushBranch(currentBranch, verbose);
+                // Get the current branch SHA
+                const { data: branchData } = await octokit.repos.getBranch({
+                    owner,
+                    repo,
+                    branch: currentBranch,
+                });
+                // Create the feat/ branch
+                await octokit.git.createRef({
+                    owner,
+                    repo,
+                    ref: `refs/heads/${targetBranch}`,
+                    sha: branchData.commit.sha,
+                });
+                if (verbose) {
+                    console.log(`✅ Created target branch: ${targetBranch}`);
+                }
+            }
+            catch (error) {
+                // If branch already exists, that's fine
+                if (!error.message?.includes('Reference already exists')) {
+                    throw error;
+                }
+                if (verbose) {
+                    console.log(`ℹ️ Target branch ${targetBranch} already exists`);
+                }
+            }
+        }
+        else {
+            // If not a dev/ branch, push it normally
+            pushBranch(currentBranch, verbose);
+        }
         // Generate PR title and body
         const title = generatePRTitle(feature.name);
         const body = generatePRBody(feature);
         if (verbose) {
-            console.log(`📝 Creating pull request: ${title}`);
+            console.log(`📝 Creating pull request: ${title} from ${currentBranch} to ${targetBranch}`);
         }
-        // Create the pull request
+        // Create the pull request from dev/ to feat/
         const { data: pullRequest } = await octokit.pulls.create({
             owner,
             repo,
             title,
             body,
             head: currentBranch,
-            base: baseBranch,
+            base: targetBranch,
             draft: false,
         });
         if (verbose) {

package/dist/phases/pull-request/handler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pull request creation handler for pipeline execution
+ */
+import { PipelineResult } from '../../types/pipeline.js';
+export interface PullRequestHandlerOptions {
+    featureId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+    results: readonly PipelineResult[];
+    testingResult: PipelineResult;
+    verbose?: boolean;
+}
+/**
+ * Create pull request for successful feature implementation
+ */
+export declare function handlePullRequestCreation({ featureId, mcpServerUrl, mcpToken, results, testingResult, verbose, }: PullRequestHandlerOptions): Promise<void>;

package/dist/phases/pull-request/handler.js

@@ -0,0 +1,60 @@
+/**
+ * Pull request creation handler for pipeline execution
+ */
+import { getFeature } from '../../api/features/index.js';
+import { createPullRequest, updateFeatureWithPullRequest } from './creator.js';
+/**
+ * Create pull request for successful feature implementation
+ */
+export async function handlePullRequestCreation({ featureId, mcpServerUrl, mcpToken, results, testingResult, verbose, }) {
+    if (verbose) {
+        console.log('🔄 Creating pull request for successful feature...');
+    }
+    // Get feature details for PR creation
+    const feature = await getFeature(mcpServerUrl, mcpToken, featureId, verbose);
+    if (!feature) {
+        if (verbose) {
+            console.log('⚠️ Could not fetch feature details for pull request creation');
+        }
+        return;
+    }
+    // Get GitHub configuration from environment
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    const githubOwner = process.env.GITHUB_OWNER;
+    const githubRepo = process.env.GITHUB_REPO;
+    if (!githubToken || !githubOwner || !githubRepo) {
+        if (verbose) {
+            console.log('⚠️ GitHub configuration not found. Skipping pull request creation.');
+            console.log('   Set GITHUB_TOKEN, GITHUB_OWNER, and GITHUB_REPO environment variables.');
+        }
+        return;
+    }
+    const prResult = await createPullRequest({
+        githubToken,
+        owner: githubOwner,
+        repo: githubRepo,
+        baseBranch: 'main',
+        verbose,
+    }, {
+        id: feature.id,
+        name: feature.name,
+        description: feature.description || '',
+        productId: feature.product_id,
+        // Get technical design and test result from previous phases
+        technicalDesign: results.find((r) => r.phase === 'technical-design')?.data?.technicalDesign,
+        testResult: testingResult.data?.testResult,
+        testReportUrl: testingResult.data?.testReport?.testReportUrl,
+    });
+    if (prResult.success && prResult.pullRequestUrl) {
+        // Update feature with PR URL and status
+        await updateFeatureWithPullRequest(mcpServerUrl, mcpToken, featureId, prResult.pullRequestUrl, verbose);
+        if (verbose) {
+            console.log(`✅ Pull request created and feature updated to ready_for_review`);
+        }
+    }
+    else {
+        if (verbose) {
+            console.log(`⚠️ Pull request creation failed: ${prResult.error}`);
+        }
+    }
+}

package/dist/{technical-design → phases/technical-design}/analyzer.d.ts

@@ -1,4 +1,5 @@
-import { EdsgerConfig } from '../types.js';
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
 export interface TechnicalDesignOptions {
     featureId: string;
     mcpServerUrl: string;
@@ -11,6 +12,10 @@ export interface TechnicalDesignResult {
     status: 'success' | 'error';
     summary: string;
     savedViaHttp?: boolean;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
 }
-export declare const generateTechnicalDesign: (options: TechnicalDesignOptions, config: EdsgerConfig) => Promise<TechnicalDesignResult>;
+export declare const generateTechnicalDesign: (options: TechnicalDesignOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<TechnicalDesignResult>;
 export declare const checkTechnicalDesignRequirements: () => Promise<boolean>;