edsger 0.2.2 → 0.2.4

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

@@ -0,0 +1,450 @@
+/**
+ * Helper functions for feature analysis
+ * Extracted from analyzer.ts to improve modularity and testability
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { saveDataViaHttp } from './http-fallback.js';
+import { createUserStories, createTestCases, batchUpdateUserStoryStatus, batchUpdateTestCaseStatus, batchDeleteUserStories, batchDeleteTestCases, } from '../../api/features/index.js';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { verifyChecklistCompliance, } from '../feature-analysis-verification/index.js';
+import { createImprovementPrompt } from '../../prompts/feature-analysis-improvement.js';
+import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(analysisPrompt) {
+    yield userMessage(analysisPrompt);
+}
+/**
+ * Parse JSON result from Claude Code response
+ */
+export function parseAnalysisResult(responseText) {
+    try {
+        let jsonResult = null;
+        // First try to extract JSON from markdown code block
+        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+        if (jsonBlockMatch) {
+            jsonResult = JSON.parse(jsonBlockMatch[1]);
+        }
+        else {
+            // Try to parse the entire response as JSON
+            jsonResult = JSON.parse(responseText);
+        }
+        if (jsonResult && jsonResult.analysis) {
+            return { analysis: jsonResult.analysis };
+        }
+        else {
+            return { error: 'Invalid JSON structure' };
+        }
+    }
+    catch (error) {
+        return {
+            error: `JSON parsing failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/**
+ * Execute a single analysis query
+ */
+export async function executeAnalysisQuery(currentPrompt, systemPrompt, config, verbose) {
+    let lastAssistantResponse = '';
+    let structuredAnalysisResult = null;
+    for await (const message of query({
+        prompt: prompt(currentPrompt),
+        options: {
+            appendSystemPrompt: systemPrompt,
+            model: config.claude.model || 'sonnet',
+            maxTurns: 1000,
+            permissionMode: 'bypassPermissions',
+        },
+    })) {
+        if (verbose) {
+            logInfo(`Received message type: ${message.type}`);
+        }
+        // Stream the analysis process and capture assistant responses
+        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📊 Feature analysis completed, parsing results...');
+                const responseText = message.result || lastAssistantResponse;
+                const parsed = parseAnalysisResult(responseText);
+                if (parsed.error) {
+                    logError(`Failed to parse structured analysis result: ${parsed.error}`);
+                    structuredAnalysisResult = {
+                        status: 'error',
+                        summary: 'Failed to parse analysis results from Claude Code response',
+                        created_user_stories: [],
+                        created_test_cases: [],
+                    };
+                }
+                else {
+                    structuredAnalysisResult = parsed.analysis;
+                }
+            }
+            else {
+                logError(`\n⚠️ Analysis 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) {
+                    const parsed = parseAnalysisResult(lastAssistantResponse);
+                    if (!parsed.error) {
+                        structuredAnalysisResult = parsed.analysis;
+                    }
+                }
+            }
+        }
+    }
+    return structuredAnalysisResult;
+}
+/**
+ * Perform verification and determine if iteration should continue
+ * This function only verifies - it does NOT manage artifacts (save/delete/update)
+ */
+export async function performVerificationCycle(structuredAnalysisResult, checklistContext, context, config, currentIteration, maxIterations, mcpServerUrl, mcpToken, featureId, verbose) {
+    // No verification needed if no checklist context
+    if (!checklistContext || checklistContext.checklists.length === 0) {
+        return { passed: true, verificationResult: null };
+    }
+    const { created_user_stories, created_test_cases } = structuredAnalysisResult;
+    if (verbose) {
+        logInfo('🔍 Starting checklist verification...');
+    }
+    const verificationResult = await verifyChecklistCompliance({
+        checklistContext,
+        analysisContext: context,
+        createdUserStories: created_user_stories || [],
+        createdTestCases: created_test_cases || [],
+        verbose,
+    }, config);
+    // Verification passed
+    if (verificationResult.rejected_count === 0) {
+        if (verbose) {
+            logInfo(`✅ Checklist verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
+        }
+        // Log verification success
+        await logFeatureVerificationEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            phase: 'feature_analysis',
+            iteration: currentIteration,
+            result: 'success',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                summary: verificationResult.summary,
+            },
+        }, verbose);
+        return { passed: true, verificationResult };
+    }
+    // Verification failed
+    logError(`❌ Iteration ${currentIteration}: Checklist verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
+    // Log verification failure with improvement suggestions
+    await logFeatureVerificationEvent(mcpServerUrl, mcpToken, {
+        featureId,
+        phase: 'feature_analysis',
+        iteration: currentIteration,
+        result: 'error',
+        verificationData: {
+            confirmed_count: verificationResult.confirmed_count,
+            rejected_count: verificationResult.rejected_count,
+            uncertain_count: verificationResult.uncertain_count,
+            rejected_items: verificationResult.item_verifications
+                .filter((item) => item.verification_status === 'rejected')
+                .map((item) => ({
+                checklist_item_id: item.checklist_item_id,
+                reason: item.verification_reason || 'No reason provided',
+                concerns: item.concerns || [],
+                improvement_suggestions: item.improvement_suggestions || [],
+            })),
+            uncertain_items: verificationResult.item_verifications
+                .filter((item) => item.verification_status === 'uncertain')
+                .map((item) => ({
+                checklist_item_id: item.checklist_item_id,
+                reason: item.verification_reason || 'No reason provided',
+                concerns: item.concerns || [],
+                improvement_suggestions: item.improvement_suggestions || [],
+            })),
+            summary: verificationResult.summary,
+            overall_suggestions: verificationResult.overall_suggestions || [],
+        },
+    }, verbose);
+    // Check if we can iterate again
+    if (currentIteration < maxIterations) {
+        if (verbose) {
+            logInfo(`   Will retry with improvement feedback (${maxIterations - currentIteration} attempts remaining)`);
+        }
+        // Create improvement prompt for next iteration
+        const nextPrompt = createImprovementPrompt(verificationResult, {
+            created_user_stories: created_user_stories || [],
+            created_test_cases: created_test_cases || [],
+        });
+        return { passed: false, verificationResult, nextPrompt };
+    }
+    // Max iterations reached
+    logError(`❌ Maximum iterations (${maxIterations}) reached. Checklist verification still failing.`);
+    return { passed: false, verificationResult };
+}
+/**
+ * Save analysis artifacts as draft and return their IDs
+ */
+export async function saveAnalysisArtifactsAsDraft(mcpServerUrl, mcpToken, featureId, created_user_stories, created_test_cases, verbose) {
+    const userStoryIds = [];
+    const testCaseIds = [];
+    // Save user stories as draft
+    if (created_user_stories && created_user_stories.length > 0) {
+        if (verbose) {
+            logInfo(`Saving ${created_user_stories.length} user stories as draft...`);
+        }
+        try {
+            const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/create', {
+                feature_id: featureId,
+                user_stories: created_user_stories.map((story) => ({
+                    title: story.title,
+                    description: story.description,
+                    status: 'draft',
+                })),
+            }));
+            if (result.created_user_stories) {
+                userStoryIds.push(...result.created_user_stories.map((story) => story.id));
+                if (verbose) {
+                    logInfo(`✅ Saved ${userStoryIds.length} user stories as draft`);
+                }
+            }
+        }
+        catch (error) {
+            logError(`Failed to save user stories: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Save test cases as draft
+    if (created_test_cases && created_test_cases.length > 0) {
+        if (verbose) {
+            logInfo(`Saving ${created_test_cases.length} test cases as draft...`);
+        }
+        try {
+            const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/create', {
+                feature_id: featureId,
+                test_cases: created_test_cases.map((testCase) => ({
+                    name: testCase.name,
+                    description: testCase.description,
+                    is_critical: testCase.is_critical || false,
+                    status: 'draft',
+                })),
+            }));
+            if (result.created_test_cases) {
+                testCaseIds.push(...result.created_test_cases.map((testCase) => testCase.id));
+                if (verbose) {
+                    logInfo(`✅ Saved ${testCaseIds.length} test cases as draft`);
+                }
+            }
+        }
+        catch (error) {
+            logError(`Failed to save test cases: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { userStoryIds, testCaseIds };
+}
+/**
+ * Update artifacts to ready status after successful verification
+ */
+export async function updateArtifactsToReady(mcpServerUrl, mcpToken, userStoryIds, testCaseIds, verbose) {
+    if (userStoryIds.length > 0) {
+        if (verbose) {
+            logInfo(`Updating ${userStoryIds.length} user stories from draft to ready...`);
+        }
+        await batchUpdateUserStoryStatus(mcpServerUrl, mcpToken, userStoryIds, 'ready', verbose);
+    }
+    if (testCaseIds.length > 0) {
+        if (verbose) {
+            logInfo(`Updating ${testCaseIds.length} test cases from draft to ready...`);
+        }
+        await batchUpdateTestCaseStatus(mcpServerUrl, mcpToken, testCaseIds, 'ready', verbose);
+    }
+}
+/**
+ * Delete artifacts after verification failure
+ */
+export async function deleteArtifacts(mcpServerUrl, mcpToken, userStoryIds, testCaseIds, verbose) {
+    if (userStoryIds.length > 0) {
+        if (verbose) {
+            logInfo(`Deleting ${userStoryIds.length} user stories due to verification failure...`);
+        }
+        await batchDeleteUserStories(mcpServerUrl, mcpToken, userStoryIds, verbose);
+    }
+    if (testCaseIds.length > 0) {
+        if (verbose) {
+            logInfo(`Deleting ${testCaseIds.length} test cases due to verification failure...`);
+        }
+        await batchDeleteTestCases(mcpServerUrl, mcpToken, testCaseIds, verbose);
+    }
+}
+/**
+ * Save analysis artifacts (user stories and test cases) - Legacy function for non-verification flows
+ */
+export async function saveAnalysisArtifacts(mcpServerUrl, mcpToken, featureId, created_user_stories, created_test_cases, status, verbose) {
+    if (created_user_stories && created_user_stories.length > 0) {
+        if (verbose) {
+            logInfo('Saving created user stories...');
+        }
+        const userStoriesCreated = await createUserStories(mcpServerUrl, mcpToken, featureId, created_user_stories, verbose);
+        if (!userStoriesCreated && verbose) {
+            logError('⚠️ Failed to save user stories');
+        }
+    }
+    if (created_test_cases && created_test_cases.length > 0) {
+        if (verbose) {
+            logInfo('Saving created test cases...');
+        }
+        const testCasesCreated = await createTestCases(mcpServerUrl, mcpToken, featureId, created_test_cases, verbose);
+        if (!testCasesCreated && verbose) {
+            logError('⚠️ Failed to save test cases');
+        }
+    }
+    // Try HTTP fallback if direct save failed
+    if (status === 'error' &&
+        (created_user_stories?.length > 0 || created_test_cases?.length > 0)) {
+        if (verbose) {
+            logInfo('Direct save failed, trying HTTP fallback...');
+        }
+        const httpSuccess = await saveDataViaHttp({
+            mcpServerUrl,
+            mcpToken,
+            featureId,
+            userStories: created_user_stories || [],
+            testCases: created_test_cases || [],
+            verbose,
+        });
+        if (httpSuccess) {
+            logInfo('✅ Successfully saved data via HTTP fallback');
+        }
+        else if (verbose) {
+            logError('❌ HTTP fallback also failed');
+        }
+    }
+}
+/**
+ * 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,
+        },
+    };
+}
+/**
+ * Build error result when verification fails after all iterations
+ */
+export function buildVerificationFailureResult(featureId, context, verificationResult, checklist_results, checklist_item_results, currentIteration) {
+    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: [],
+        createdTestCases: [],
+        summary: `Checklist verification failed after ${currentIteration} iterations: ${verificationResult.summary}`,
+        status: 'error',
+        data: {
+            checklist_results,
+            checklist_item_results,
+            verification_result: verificationResult,
+            iterations: currentIteration,
+        },
+    };
+}
+/**
+ * Build error result when no analysis results are received
+ */
+export function buildNoResultsError(featureId, context) {
+    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: [],
+        createdTestCases: [],
+        summary: 'No analysis results received',
+        status: 'error',
+        data: {
+            checklist_results: undefined,
+            checklist_item_results: undefined,
+        },
+    };
+}

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

@@ -5,6 +5,7 @@ export interface FeatureAnalysisOptions {
     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>;