edsger 0.41.1 → 0.41.2

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

@@ -0,0 +1,296 @@
+/**
+ * Context fetcher for code review phase
+ * Fetches GitHub PR data including files, diffs, and commits for review
+ */
+import { Octokit } from '@octokit/rest';
+import { getFeature } from '../../api/features/get-feature.js';
+/**
+ * Extract owner, repo, and PR number from GitHub PR URL
+ */
+export function parsePullRequestUrl(pullRequestUrl) {
+    const match = pullRequestUrl.match(/github\.com\/([^\/]+)\/([^\/]+)\/pull\/(\d+)/);
+    if (!match) {
+        return null;
+    }
+    return {
+        owner: match[1],
+        repo: match[2],
+        prNumber: parseInt(match[3], 10),
+    };
+}
+/**
+ * Fetch PR details
+ */
+export async function fetchPRDetails(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`📋 Fetching PR details for ${owner}/${repo}#${prNumber}...`);
+    }
+    const { data } = await octokit.pulls.get({
+        owner,
+        repo,
+        pull_number: prNumber,
+    });
+    if (verbose) {
+        console.log(`✅ Fetched PR: ${data.title}`);
+    }
+    return data;
+}
+/**
+ * Fetch PR files (changed files with diffs)
+ */
+export async function fetchPRFiles(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`📂 Fetching PR files for ${owner}/${repo}#${prNumber}...`);
+    }
+    const { data: files } = await octokit.pulls.listFiles({
+        owner,
+        repo,
+        pull_number: prNumber,
+        per_page: 100,
+    });
+    if (verbose) {
+        console.log(`✅ Found ${files.length} changed files`);
+    }
+    return files;
+}
+/**
+ * Fetch PR commits
+ */
+export async function fetchPRCommits(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`💾 Fetching PR commits for ${owner}/${repo}#${prNumber}...`);
+    }
+    const { data: commits } = await octokit.pulls.listCommits({
+        owner,
+        repo,
+        pull_number: prNumber,
+        per_page: 100,
+    });
+    if (verbose) {
+        console.log(`✅ Found ${commits.length} commits`);
+    }
+    return commits;
+}
+/**
+ * Fetch user stories via MCP
+ */
+export async function fetchUserStories(featureId, verbose) {
+    try {
+        if (verbose) {
+            console.log(`📖 Fetching user stories for ${featureId}...`);
+        }
+        const mcpServerUrl = process.env.MCP_SERVER_URL;
+        const mcpToken = process.env.MCP_TOKEN;
+        const response = await fetch(`${mcpServerUrl}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${mcpToken}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'user_stories/list',
+                params: {
+                    feature_id: featureId,
+                },
+            }),
+        });
+        if (!response.ok) {
+            if (verbose) {
+                console.log(`⚠️ Could not fetch user stories: ${response.status}`);
+            }
+            return [];
+        }
+        const data = await response.json();
+        if (data.error || !data.result) {
+            if (verbose) {
+                console.log(`⚠️ User stories not available`);
+            }
+            return [];
+        }
+        return data.result.user_stories || [];
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(`⚠️ Error fetching user stories: ${error}`);
+        }
+        return [];
+    }
+}
+/**
+ * Fetch test cases via MCP
+ */
+export async function fetchTestCases(featureId, verbose) {
+    try {
+        if (verbose) {
+            console.log(`🧪 Fetching test cases for ${featureId}...`);
+        }
+        const mcpServerUrl = process.env.MCP_SERVER_URL;
+        const mcpToken = process.env.MCP_TOKEN;
+        const response = await fetch(`${mcpServerUrl}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${mcpToken}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'test_cases/list',
+                params: {
+                    feature_id: featureId,
+                },
+            }),
+        });
+        if (!response.ok) {
+            if (verbose) {
+                console.log(`⚠️ Could not fetch test cases: ${response.status}`);
+            }
+            return [];
+        }
+        const data = await response.json();
+        if (data.error || !data.result) {
+            if (verbose) {
+                console.log(`⚠️ Test cases not available`);
+            }
+            return [];
+        }
+        return data.result.test_cases || [];
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(`⚠️ Error fetching test cases: ${error}`);
+        }
+        return [];
+    }
+}
+/**
+ * Fetch complete code review context
+ */
+export async function fetchCodeReviewContext(featureId, githubToken, verbose) {
+    // Fetch feature info using shared API
+    const feature = await getFeature(featureId, verbose);
+    if (!feature.pull_request_url) {
+        throw new Error(`Feature ${featureId} does not have a pull request URL. Cannot perform code review.`);
+    }
+    // Parse PR URL
+    const prInfo = parsePullRequestUrl(feature.pull_request_url);
+    if (!prInfo) {
+        throw new Error(`Invalid pull request URL: ${feature.pull_request_url}. Expected format: https://github.com/owner/repo/pull/123`);
+    }
+    const { owner, repo, prNumber } = prInfo;
+    // Initialize Octokit with GitHub token
+    const octokit = new Octokit({
+        auth: githubToken,
+    });
+    // Fetch PR data, files, commits, and additional context in parallel
+    const [prData, files, commits, userStories, testCases] = await Promise.all([
+        fetchPRDetails(octokit, owner, repo, prNumber, verbose),
+        fetchPRFiles(octokit, owner, repo, prNumber, verbose),
+        fetchPRCommits(octokit, owner, repo, prNumber, verbose),
+        fetchUserStories(featureId, verbose),
+        fetchTestCases(featureId, verbose),
+    ]);
+    if (verbose) {
+        console.log(`📊 Summary: ${files.length} files changed across ${commits.length} commits`);
+    }
+    return {
+        featureId,
+        featureName: feature.name,
+        featureDescription: feature.description ?? null,
+        pullRequestUrl: feature.pull_request_url,
+        pullRequestNumber: prNumber,
+        owner,
+        repo,
+        prData,
+        files,
+        commits,
+        technicalDesign: feature.technical_design,
+        userStories,
+        testCases,
+    };
+}
+/**
+ * Format code review context for prompt
+ */
+export function formatContextForPrompt(context) {
+    const sections = [];
+    // Feature information
+    sections.push(`# Feature Information`);
+    sections.push(`**Feature ID**: ${context.featureId}`);
+    sections.push(`**Feature Name**: ${context.featureName}`);
+    if (context.featureDescription) {
+        sections.push(`**Description**: ${context.featureDescription}`);
+    }
+    sections.push(`**Pull Request**: ${context.pullRequestUrl} (#${context.pullRequestNumber})`);
+    sections.push('');
+    // PR details
+    sections.push(`## Pull Request Details`);
+    sections.push(`**Title**: ${context.prData.title}`);
+    sections.push(`**Author**: @${context.prData.user.login}`);
+    sections.push(`**Base Branch**: ${context.prData.base.ref}`);
+    sections.push(`**Head Branch**: ${context.prData.head.ref}`);
+    if (context.prData.body) {
+        sections.push(`**Description**:`);
+        sections.push(context.prData.body);
+    }
+    sections.push('');
+    // Commits
+    if (context.commits.length > 0) {
+        sections.push(`## Commits (${context.commits.length})`);
+        sections.push('');
+        context.commits.forEach((commit) => {
+            sections.push(`- **${commit.sha.substring(0, 7)}**: ${commit.commit.message}`);
+            sections.push(`  by ${commit.commit.author.name} on ${commit.commit.author.date}`);
+        });
+        sections.push('');
+    }
+    // Changed files
+    if (context.files.length > 0) {
+        sections.push(`## Changed Files (${context.files.length})`);
+        sections.push('');
+        context.files.forEach((file) => {
+            sections.push(`### ${file.filename}`);
+            sections.push(`**Status**: ${file.status}`);
+            sections.push(`**Changes**: +${file.additions} -${file.deletions}`);
+            if (file.patch) {
+                sections.push(`**Diff**:`);
+                sections.push('```diff');
+                sections.push(file.patch);
+                sections.push('```');
+            }
+            sections.push('');
+        });
+    }
+    // Technical design
+    if (context.technicalDesign) {
+        sections.push(`## Technical Design`);
+        sections.push('');
+        sections.push(context.technicalDesign);
+        sections.push('');
+    }
+    // User stories
+    if (context.userStories && context.userStories.length > 0) {
+        sections.push(`## User Stories`);
+        sections.push('');
+        context.userStories.forEach((story) => {
+            sections.push(`### ${story.title}`);
+            sections.push(story.description || '');
+            sections.push('');
+        });
+    }
+    // Test cases
+    if (context.testCases && context.testCases.length > 0) {
+        sections.push(`## Test Cases`);
+        sections.push('');
+        context.testCases.forEach((testCase) => {
+            sections.push(`### ${testCase.title}`);
+            if (testCase.description) {
+                sections.push(testCase.description);
+            }
+            sections.push('');
+        });
+    }
+    return sections.join('\n');
+}

package/dist/phases/feature-analysis/analyzer-helpers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Helper functions for feature analysis
+ * Extracted from analyzer.ts to improve modularity and testability
+ */
+import { FeatureAnalysisResult } from '../../types/index.js';
+import { FeatureAnalysisContext } from './context.js';
+/**
+ * Build the final analysis result object
+ */
+export declare function buildAnalysisResult(featureId: string, context: FeatureAnalysisContext, structuredAnalysisResult: any, currentIteration: number): FeatureAnalysisResult;

package/dist/phases/feature-analysis/analyzer-helpers.js

@@ -0,0 +1,47 @@
+/**
+ * Build the final analysis result object
+ */
+export function buildAnalysisResult(featureId, context, structuredAnalysisResult, currentIteration) {
+    const { created_user_stories, created_test_cases, checklist_results, checklist_item_results, } = structuredAnalysisResult;
+    return {
+        featureId,
+        productInfo: context.product,
+        featureInfo: context.feature,
+        existingUserStories: context.existing_user_stories.map((story) => ({
+            ...story,
+            status: story.status,
+            created_at: story.created_at || new Date().toISOString(),
+            updated_at: story.updated_at || new Date().toISOString(),
+        })),
+        existingTestCases: context.existing_test_cases.map((testCase) => ({
+            ...testCase,
+            created_at: testCase.created_at || new Date().toISOString(),
+            updated_at: testCase.updated_at || new Date().toISOString(),
+        })),
+        createdUserStories: (created_user_stories || []).map((story) => ({
+            id: '',
+            title: story.title,
+            description: story.description,
+            status: story.status || 'draft',
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+        })),
+        createdTestCases: (created_test_cases || []).map((testCase) => ({
+            id: '',
+            name: testCase.name,
+            description: testCase.description,
+            is_critical: testCase.is_critical || false,
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+        })),
+        summary: structuredAnalysisResult.summary ||
+            `Analysis completed${currentIteration > 1 ? ` after ${currentIteration} iterations` : ''}`,
+        status: structuredAnalysisResult.status === 'success' ? 'success' : 'error',
+        data: {
+            checklist_results,
+            checklist_item_results,
+            verification_result: structuredAnalysisResult.verification_result,
+            iterations: currentIteration,
+        },
+    };
+}

package/dist/phases/feature-analysis/analyzer.d.ts

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

package/dist/phases/feature-analysis/analyzer.js

@@ -0,0 +1,208 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { fetchFeatureAnalysisContext, } from './context-fetcher.js';
+import { formatFeatureAnalysisContext } from '../../utils/formatters.js';
+import { createFeatureAnalysisSystemPrompt, createFeatureAnalysisPromptWithContext, } from './prompts.js';
+import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
+import { executeAnalysisQuery, performVerificationCycle, saveAnalysisArtifactsAsDraft, updateArtifactsToReady, deleteArtifacts, buildAnalysisResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+export const analyzeFeatureWithMCP = async (options, config, checklistContext) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting feature analysis for feature ID: ${featureId}`);
+        logInfo(`Using MCP server: ${mcpServerUrl}`);
+    }
+    try {
+        // Fetch and prepare context
+        const context = await prepareAnalysisContext(mcpServerUrl, mcpToken, featureId, checklistContext, verbose);
+        const systemPrompt = createFeatureAnalysisSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
+        const initialAnalysisPrompt = context.analysisPrompt;
+        const maxIterations = options.maxVerificationIterations || 10;
+        let currentIteration = 0;
+        let currentPrompt = initialAnalysisPrompt;
+        let structuredAnalysisResult = null;
+        let verificationResult = null;
+        if (verbose) {
+            logInfo('Starting Claude Code query with pre-fetched information...');
+        }
+        // Iterative improvement loop: analysis → save draft → verification → update ready or delete → re-analysis
+        let currentDraftUserStoryIds = [];
+        let currentDraftTestCaseIds = [];
+        while (currentIteration < maxIterations) {
+            currentIteration++;
+            if (verbose && currentIteration > 1) {
+                logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Improving analysis based on verification feedback...`);
+            }
+            // Log iteration start (for iterations after the first)
+            if (currentIteration > 1) {
+                await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                    featureId,
+                    eventType: 'phase_started',
+                    phase: 'feature_analysis',
+                    result: 'info',
+                    metadata: {
+                        iteration: currentIteration,
+                        max_iterations: maxIterations,
+                        re_analysis: true,
+                        timestamp: new Date().toISOString(),
+                    },
+                }, verbose);
+            }
+            // Execute analysis query
+            structuredAnalysisResult = await executeAnalysisQuery(currentPrompt, systemPrompt, config, verbose);
+            // No result produced, break out
+            if (!structuredAnalysisResult) {
+                break;
+            }
+            // Log analysis completion for this iteration
+            await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                featureId,
+                eventType: 'phase_completed',
+                phase: 'feature_analysis',
+                result: 'success',
+                metadata: {
+                    iteration: currentIteration,
+                    max_iterations: maxIterations,
+                    analysis_step: 'completed',
+                    user_stories_count: structuredAnalysisResult.created_user_stories?.length || 0,
+                    test_cases_count: structuredAnalysisResult.created_test_cases?.length || 0,
+                    timestamp: new Date().toISOString(),
+                },
+            }, verbose);
+            // Save artifacts as draft and get their IDs
+            const { userStoryIds, testCaseIds } = await saveAnalysisArtifactsAsDraft(mcpServerUrl, mcpToken, featureId, structuredAnalysisResult.created_user_stories || [], structuredAnalysisResult.created_test_cases || [], verbose);
+            currentDraftUserStoryIds = userStoryIds;
+            currentDraftTestCaseIds = testCaseIds;
+            // Perform verification cycle
+            const verificationCycle = await performVerificationCycle(structuredAnalysisResult, checklistContext || null, context.featureContext, config, currentIteration, maxIterations, mcpServerUrl, mcpToken, featureId, verbose);
+            verificationResult = verificationCycle.verificationResult;
+            // If verification passed, update artifacts to ready and exit
+            if (verificationCycle.passed) {
+                if (verbose) {
+                    logInfo('✅ Verification passed! Updating artifacts to ready status...');
+                }
+                await updateArtifactsToReady(mcpServerUrl, mcpToken, currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
+                break;
+            }
+            // Verification failed
+            if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
+                // We have more iterations - delete draft artifacts and retry
+                if (verbose) {
+                    logInfo('🗑️  Deleting draft artifacts for re-analysis...');
+                }
+                await deleteArtifacts(mcpServerUrl, mcpToken, currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
+                // Continue with improvement prompt
+                currentPrompt = verificationCycle.nextPrompt;
+            }
+            else {
+                // Max iterations reached or no next prompt - exit loop
+                // Draft artifacts remain in database for manual review
+                if (verbose) {
+                    logInfo('⚠️  Max iterations reached. Draft artifacts kept for manual review.');
+                }
+                break;
+            }
+        }
+        // Handle results
+        if (!structuredAnalysisResult) {
+            return buildNoResultsError(featureId, context.featureContext);
+        }
+        const { created_user_stories, created_test_cases, status, checklist_results, checklist_item_results, } = structuredAnalysisResult;
+        // If no checklist was used, update draft artifacts to ready now
+        if (!checklistContext ||
+            checklistContext.checklists.length === 0 ||
+            !verificationResult) {
+            if (currentDraftUserStoryIds.length > 0 ||
+                currentDraftTestCaseIds.length > 0) {
+                if (verbose) {
+                    logInfo('✅ No checklist verification needed. Updating artifacts to ready status...');
+                }
+                await updateArtifactsToReady(mcpServerUrl, mcpToken, currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
+            }
+        }
+        // Check if verification failed after all iterations
+        // Note: Artifacts are already saved as draft in the database
+        // If verification failed, they remain as draft for manual review
+        if (verificationResult &&
+            verificationResult.rejected_count > 0 &&
+            checklistContext &&
+            checklistContext.checklists.length > 0) {
+            logError(`❌ Final result: Checklist verification FAILED after ${currentIteration} iterations`);
+            logError(`   Draft artifacts (${currentDraftUserStoryIds.length} user stories, ${currentDraftTestCaseIds.length} test cases) kept for manual review`);
+            return buildVerificationFailureResult(featureId, context.featureContext, verificationResult, checklist_results, checklist_item_results, currentIteration);
+        }
+        // Return success result
+        // Note: Artifacts have already been saved and updated to 'ready' status (if verification passed)
+        // or remain as draft (if verification failed)
+        return buildAnalysisResult(featureId, context.featureContext, structuredAnalysisResult, currentIteration);
+    }
+    catch (error) {
+        logError(`Feature analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            featureId,
+            productInfo: null,
+            featureInfo: null,
+            existingUserStories: [],
+            existingTestCases: [],
+            createdUserStories: [],
+            createdTestCases: [],
+            summary: `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+            status: 'error',
+        };
+    }
+};
+/**
+ * Prepare all context information needed for analysis
+ */
+async function prepareAnalysisContext(mcpServerUrl, mcpToken, featureId, checklistContext, verbose) {
+    if (verbose) {
+        logInfo('Fetching feature analysis context via MCP endpoints...');
+    }
+    const featureContext = await fetchFeatureAnalysisContext(mcpServerUrl, mcpToken, featureId, verbose);
+    const { content: contextInfo, downloadedImages } = await formatFeatureAnalysisContext(featureContext);
+    if (verbose && downloadedImages.length > 0) {
+        logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
+        downloadedImages.forEach((img) => {
+            logInfo(`  - ${img.url} -> ${img.localPath}`);
+        });
+    }
+    let finalContextInfo = contextInfo;
+    // Add feedbacks context to the analysis prompt
+    try {
+        const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'feature-analysis');
+        if (feedbacksContext.feedbacks.length > 0) {
+            const feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+            finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+            if (verbose) {
+                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to context`);
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail if feedbacks fetch fails - just log and continue
+        if (verbose) {
+            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    // Add checklist context to the analysis prompt
+    if (checklistContext && checklistContext.checklists.length > 0) {
+        const checklistInfo = formatChecklistsForContext(checklistContext);
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
+        if (verbose) {
+            logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
+        }
+    }
+    const analysisPrompt = createFeatureAnalysisPromptWithContext(featureId, finalContextInfo);
+    return { featureContext, analysisPrompt };
+}
+export const checkFeatureAnalysisRequirements = 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('Feature analysis requirements check failed:', error instanceof Error ? error.message : error);
+        return false;
+    }
+};

package/dist/phases/feature-analysis/context-fetcher.d.ts

@@ -0,0 +1,26 @@
+import { createUserStories, createTestCases } from '../../api/features/index.js';
+import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
+import { type ProductInfo } from '../../api/products.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface FeatureAnalysisContext {
+    feature: FeatureInfo;
+    product: ProductInfo;
+    existing_user_stories: UserStory[];
+    existing_test_cases: TestCase[];
+}
+/**
+ * Fetch all feature analysis context information via MCP endpoints
+ */
+export declare function fetchFeatureAnalysisContext(featureId: string, verbose?: boolean): Promise<FeatureAnalysisContext>;
+export { createUserStories, createTestCases };
+/**
+ * Format the context into a readable string for Claude Code
+ */
+export declare function formatContextForPrompt(context: FeatureAnalysisContext): string;
+/**
+ * Prepare all context information needed for analysis
+ */
+export declare function prepareAnalysisContext(featureId: string, checklistContext: ChecklistPhaseContext | null | undefined, verbose?: boolean): Promise<{
+    featureContext: FeatureAnalysisContext;
+    analysisPrompt: string;
+}>;