edsger 0.41.1 → 0.41.2

package/dist/phases/feature-analysis/context-fetcher.js

@@ -0,0 +1,134 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature, getUserStories, createUserStories, getTestCases, createTestCases, } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
+import { formatFeatureAnalysisContext } from '../../utils/formatters.js';
+import { createFeatureAnalysisPromptWithContext, } from './prompts.js';
+/**
+ * Fetch all feature analysis context information via MCP endpoints
+ */
+export async function fetchFeatureAnalysisContext(featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching complete feature analysis context for feature: ${featureId}`);
+        }
+        // Fetch all required data in parallel for better performance
+        const [feature, existing_user_stories, existing_test_cases] = await Promise.all([
+            getFeature(featureId, verbose),
+            getUserStories(featureId, verbose),
+            getTestCases(featureId, verbose),
+        ]);
+        const product = await getProduct(feature.product_id, verbose);
+        if (verbose) {
+            logInfo(`✅ Feature analysis context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   Existing User Stories: ${existing_user_stories.length}`);
+            logInfo(`   Existing Test Cases: ${existing_test_cases.length}`);
+        }
+        return {
+            feature,
+            product,
+            existing_user_stories,
+            existing_test_cases,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch feature analysis context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}
+// Re-export the create functions for convenience
+export { createUserStories, createTestCases };
+/**
+ * Format the context into a readable string for Claude Code
+ */
+export function formatContextForPrompt(context) {
+    const formatUserStories = (stories) => {
+        if (stories.length === 0)
+            return 'No user stories defined.';
+        return stories
+            .map((story, index) => `${index + 1}. **${story.title}** (Status: ${story.status})
+   ${story.description}`)
+            .join('\n\n');
+    };
+    const formatTestCases = (cases) => {
+        if (cases.length === 0)
+            return 'No test cases defined.';
+        return cases
+            .map((testCase, index) => `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'}
+   ${testCase.description}`)
+            .join('\n\n');
+    };
+    return `# Feature Analysis Context
+
+## Feature Information
+- **ID**: ${context.feature.id}
+- **Name**: ${context.feature.name}
+- **Description**: ${context.feature.description || 'No description provided'}
+- **Current Status**: ${context.feature.status}
+
+## Product Information
+- **Product**: ${context.product.name}
+- **Product ID**: ${context.product.id}
+- **Description**: ${context.product.description || 'No product description'}
+
+## Existing User Stories (${context.existing_user_stories.length})
+${formatUserStories(context.existing_user_stories)}
+
+## Existing Test Cases (${context.existing_test_cases.length})
+${formatTestCases(context.existing_test_cases)}
+
+## Current Technical Design
+${context.feature.technical_design || 'No technical design available yet'}
+
+---
+
+**Analysis Instructions**: Based on the above feature information and existing user stories/test cases, conduct comprehensive business analysis to identify gaps and create additional user stories and test cases that add business value.`;
+}
+/**
+ * Prepare all context information needed for analysis
+ */
+export async function prepareAnalysisContext(featureId, checklistContext, verbose) {
+    if (verbose) {
+        logInfo('Fetching feature analysis context via MCP endpoints...');
+    }
+    const featureContext = await fetchFeatureAnalysisContext(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, 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 };
+}

package/dist/phases/feature-analysis/http-fallback.d.ts

@@ -0,0 +1,20 @@
+export interface UserStory {
+    title: string;
+    description: string;
+    status: string;
+}
+export interface TestCase {
+    name: string;
+    description: string;
+    is_critical: boolean;
+}
+export interface HttpFallbackOptions {
+    mcpServerUrl: string;
+    mcpToken: string;
+    featureId: string;
+    userStories: UserStory[];
+    testCases: TestCase[];
+    verbose?: boolean;
+}
+export declare function saveDataViaHttp(options: HttpFallbackOptions): Promise<boolean>;
+export declare function checkMcpServerHealth(mcpServerUrl: string, mcpToken: string): Promise<boolean>;

package/dist/phases/feature-analysis/http-fallback.js

@@ -0,0 +1,95 @@
+import { logInfo, logError } from '../../utils/logger.js';
+export async function saveDataViaHttp(options) {
+    const { mcpServerUrl, mcpToken, featureId, userStories, testCases, verbose } = options;
+    if (verbose) {
+        logInfo('Using HTTP fallback to save analysis data...');
+        logInfo(`Feature ID: ${featureId}`);
+        logInfo(`User Stories to save: ${userStories.length}`);
+        logInfo(`Test Cases to save: ${testCases.length}`);
+    }
+    try {
+        // Save user stories via HTTP using MCP protocol
+        if (userStories.length > 0) {
+            const userStoriesResponse = await fetch(`${mcpServerUrl}/mcp`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${mcpToken}`,
+                },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    method: 'user_stories/create',
+                    params: {
+                        feature_id: featureId,
+                        user_stories: userStories,
+                    },
+                    id: Math.random().toString(36).substring(7),
+                }),
+            });
+            if (!userStoriesResponse.ok) {
+                const errorText = await userStoriesResponse.text();
+                logError(`Failed to save user stories via HTTP: ${userStoriesResponse.status} - ${errorText}`);
+                return false;
+            }
+            const userStoriesResult = await userStoriesResponse.json();
+            if (userStoriesResult.error) {
+                logError(`MCP error creating user stories: ${userStoriesResult.error.message}`);
+                return false;
+            }
+            if (verbose) {
+                logInfo(`✅ Successfully saved ${userStories.length} user stories via HTTP`);
+            }
+        }
+        // Save test cases via HTTP using MCP protocol
+        if (testCases.length > 0) {
+            const testCasesResponse = await fetch(`${mcpServerUrl}/mcp`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${mcpToken}`,
+                },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    method: 'test_cases/create',
+                    params: {
+                        feature_id: featureId,
+                        test_cases: testCases,
+                    },
+                    id: Math.random().toString(36).substring(7),
+                }),
+            });
+            if (!testCasesResponse.ok) {
+                const errorText = await testCasesResponse.text();
+                logError(`Failed to save test cases via HTTP: ${testCasesResponse.status} - ${errorText}`);
+                return false;
+            }
+            const testCasesResult = await testCasesResponse.json();
+            if (testCasesResult.error) {
+                logError(`MCP error creating test cases: ${testCasesResult.error.message}`);
+                return false;
+            }
+            if (verbose) {
+                logInfo(`✅ Successfully saved ${testCases.length} test cases via HTTP`);
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        logError(`HTTP fallback failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+export async function checkMcpServerHealth(mcpServerUrl, mcpToken) {
+    try {
+        const response = await fetch(`${mcpServerUrl}/health`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${mcpToken}`,
+            },
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/phases/feature-analysis/mcp-server.d.ts

@@ -0,0 +1 @@
+export declare const createFeatureAnalysisMcpServer: () => import("@anthropic-ai/claude-code").McpSdkServerConfigWithInstance;

package/dist/phases/feature-analysis/mcp-server.js

@@ -0,0 +1,144 @@
+import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code';
+import { z } from 'zod';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+// Create an SDK MCP server with custom tools for feature analysis
+export const createFeatureAnalysisMcpServer = () => {
+    return createSdkMcpServer({
+        name: 'edsger-feature-analysis-mcp',
+        version: '1.0.0',
+        tools: [
+            tool('get_feature_info', 'Get comprehensive feature and product information', {
+                feature_id: z.string().describe('Feature ID to analyze'),
+            }, async (args) => {
+                try {
+                    // Get feature details using the features/get endpoint
+                    const featureResult = (await callMcpEndpoint('features/get', {
+                        feature_id: args.feature_id,
+                    }));
+                    if (!featureResult.features ||
+                        featureResult.features.length === 0) {
+                        throw new Error('Feature not found');
+                    }
+                    const feature = featureResult.features[0];
+                    // Get product details
+                    const productResult = (await callMcpEndpoint('resources/read', {
+                        uri: `product://${feature.product_id}`,
+                    }));
+                    const productText = productResult.contents?.[0]?.text || '{}';
+                    let productInfo;
+                    try {
+                        productInfo = JSON.parse(productText);
+                    }
+                    catch {
+                        productInfo = {
+                            id: feature.product_id,
+                            name: 'Unknown Product',
+                        };
+                    }
+                    const featureInfo = {
+                        feature,
+                        product: productInfo,
+                    };
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(featureInfo, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    console.error('Error in get_feature_info:', error);
+                    throw error;
+                }
+            }),
+            tool('get_existing_user_stories', 'Get existing user stories for a feature to avoid duplication', {
+                feature_id: z.string().describe('Feature ID to get user stories for'),
+            }, async (args) => {
+                const result = await callMcpEndpoint('user_stories/list', {
+                    feature_id: args.feature_id,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }),
+            tool('get_existing_test_cases', 'Get existing test cases for a feature to avoid duplication', {
+                feature_id: z.string().describe('Feature ID to get test cases for'),
+            }, async (args) => {
+                const result = await callMcpEndpoint('test_cases/list', {
+                    feature_id: args.feature_id,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }),
+            tool('create_user_stories', 'Create new user stories for a feature', {
+                feature_id: z
+                    .string()
+                    .describe('Feature ID to create user stories for'),
+                user_stories: z
+                    .array(z.object({
+                    title: z.string().describe('User story title'),
+                    description: z.string().describe('User story description'),
+                    status: z
+                        .enum(['draft', 'ready', 'in_progress', 'done', 'cancelled'])
+                        .default('draft')
+                        .describe('User story status'),
+                }))
+                    .describe('Array of user stories to create'),
+            }, async (args) => {
+                const result = await callMcpEndpoint('user_stories/create', {
+                    feature_id: args.feature_id,
+                    user_stories: args.user_stories,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }),
+            tool('create_test_cases', 'Create new test cases for a feature', {
+                feature_id: z
+                    .string()
+                    .describe('Feature ID to create test cases for'),
+                test_cases: z
+                    .array(z.object({
+                    name: z.string().describe('Test case name'),
+                    description: z.string().describe('Test case description'),
+                    is_critical: z
+                        .boolean()
+                        .default(false)
+                        .describe('Whether this is a critical test case'),
+                }))
+                    .describe('Array of test cases to create'),
+            }, async (args) => {
+                const result = await callMcpEndpoint('test_cases/create', {
+                    feature_id: args.feature_id,
+                    test_cases: args.test_cases,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }),
+        ],
+    });
+};

package/dist/phases/feature-analysis/prompts-improvement.d.ts

@@ -0,0 +1,8 @@
+import { ChecklistVerificationResult } from '../feature-analysis-verification/agent.js';
+/**
+ * Create a prompt for the analysis agent to improve based on verification feedback
+ */
+export declare const createImprovementPrompt: (verificationResult: ChecklistVerificationResult, previousAnalysis: {
+    created_user_stories: any[];
+    created_test_cases: any[];
+}) => string;

package/dist/phases/feature-analysis/prompts-improvement.js

@@ -0,0 +1,109 @@
+/**
+ * Create a prompt for the analysis agent to improve based on verification feedback
+ */
+export const createImprovementPrompt = (verificationResult, previousAnalysis) => {
+    // Format rejected items with specific feedback and improvement suggestions
+    const rejectedItemsSection = verificationResult.item_verifications
+        .filter((v) => v.verification_status === 'rejected')
+        .map((v, index) => {
+        return `### Rejected Requirement ${index + 1}
+**Checklist Item ID**: ${v.checklist_item_id}
+**Satisfaction Status**: ${v.is_satisfied ? '✅ Satisfied' : '❌ Not Satisfied'}
+**Verification Result**: ❌ REJECTED
+**Reason**: ${v.verification_reason}
+${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
+${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**💡 Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
+`;
+    })
+        .join('\n---\n');
+    // Format uncertain items with improvement suggestions
+    const uncertainItemsSection = verificationResult.item_verifications
+        .filter((v) => v.verification_status === 'uncertain')
+        .map((v, index) => {
+        return `### Uncertain Requirement ${index + 1}
+**Checklist Item ID**: ${v.checklist_item_id}
+**Satisfaction Status**: ${v.is_satisfied ? '✅ Satisfied' : '⚠️ Partially Satisfied'}
+**Verification Result**: ⚠️ UNCERTAIN
+**Reason**: ${v.verification_reason}
+${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
+${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**💡 Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
+`;
+    })
+        .join('\n---\n');
+    return `# Verification Feedback - Improvements Required
+
+Your previous analysis was verified, and **${verificationResult.rejected_count} checklist requirements were NOT SATISFIED** and **${verificationResult.uncertain_count} requirements are PARTIALLY SATISFIED**.
+
+## Verification Summary
+${verificationResult.summary}
+
+## Results Breakdown
+- ✅ Satisfied: ${verificationResult.confirmed_count}
+- ❌ Not Satisfied: ${verificationResult.rejected_count}
+- ⚠️ Partially Satisfied: ${verificationResult.uncertain_count}
+
+${verificationResult.overall_suggestions && verificationResult.overall_suggestions.length > 0 ? `## 💡 Overall Improvement Suggestions\n\n${verificationResult.overall_suggestions.map((s) => `- ${s}`).join('\n')}\n\n` : ''}
+
+${verificationResult.rejected_count > 0 ? `## ❌ Unsatisfied Requirements\n\n${rejectedItemsSection}` : ''}
+
+${verificationResult.uncertain_count > 0 ? `## ⚠️ Partially Satisfied Requirements\n\n${uncertainItemsSection}` : ''}
+
+## Your Previous Work
+
+### User Stories You Created (${previousAnalysis.created_user_stories.length})
+${previousAnalysis.created_user_stories
+        .map((story, index) => `${index + 1}. **${story.title}**
+   ${story.description}
+   Status: ${story.status || 'draft'}`)
+        .join('\n\n')}
+
+### Test Cases You Created (${previousAnalysis.created_test_cases.length})
+${previousAnalysis.created_test_cases
+        .map((tc, index) => `${index + 1}. **${tc.name}** ${tc.is_critical ? '[CRITICAL]' : '[OPTIONAL]'}
+   ${tc.description}`)
+        .join('\n\n')}
+
+---
+
+## Your Task: Improve Your Artifacts
+
+You need to **revise and improve** your user stories and test cases to satisfy the checklist requirements.
+
+**What You Should Do**:
+
+1. **Review the improvement suggestions** provided above for each rejected/uncertain requirement
+2. **Follow the specific, actionable suggestions** - they tell you exactly what to add or modify
+3. **Add NEW user stories and test cases** as suggested by the verifier
+4. **Improve the quality and specificity** of your artifacts
+5. **Ensure each requirement is adequately covered** based on the feedback
+
+**IMPORTANT Guidelines**:
+- **Pay close attention to the 💡 Improvement Suggestions** - these are specific actions you should take
+- You can **keep your existing user stories and test cases** that are good
+- **Add NEW items** exactly as suggested to satisfy the unsatisfied requirements
+- **Make your artifacts concrete and specific** - they will be verified again
+- The suggestions are your roadmap - follow them to ensure verification passes
+- Ensure your artifacts directly address the checklist requirements
+
+**CRITICAL - Output Format**:
+You MUST return ONLY the JSON object below. Do NOT include any explanatory text, commentary, or markdown before or after the JSON. Return ONLY the JSON in this exact format:
+
+\`\`\`json
+{
+  "analysis": {
+    "feature_id": "...",
+    "status": "success",
+    "summary": "Improved analysis based on verification feedback",
+    "created_user_stories": [
+      // Include ALL user stories (existing + new)
+    ],
+    "created_test_cases": [
+      // Include ALL test cases (existing + new)
+    ],
+    "recommendations": "..."
+  }
+}
+\`\`\`
+
+IMPORTANT: Return ONLY the JSON above. Do not add any text explaining what you did or how you improved the analysis. The JSON should be the complete and only content of your response.`;
+};

package/dist/phases/feature-analysis-verification/verifier.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Checklist verification agent for feature analysis
+ * This agent independently reviews checklist compliance to ensure objectivity
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { FeatureAnalysisContext } from '../feature-analysis/context-fetcher.js';
+export interface ChecklistItemVerificationResult {
+    checklist_item_id: string;
+    is_satisfied: boolean;
+    verification_status: 'confirmed' | 'rejected' | 'uncertain';
+    verification_reason: string;
+    concerns?: string[];
+    improvement_suggestions?: string[];
+}
+export interface ChecklistVerificationResult {
+    all_verified: boolean;
+    total_items: number;
+    confirmed_count: number;
+    rejected_count: number;
+    uncertain_count: number;
+    item_verifications: ChecklistItemVerificationResult[];
+    summary: string;
+    overall_suggestions?: string[];
+}
+export interface VerifyChecklistOptions {
+    checklistContext: ChecklistPhaseContext;
+    analysisContext: FeatureAnalysisContext;
+    createdUserStories: any[];
+    createdTestCases: any[];
+    verbose?: boolean;
+}
+/**
+ * Verify checklist compliance using an independent AI agent
+ * This agent acts as a "challenger" to validate the claims made by the analysis agent
+ */
+export declare function verifyChecklistCompliance(options: VerifyChecklistOptions, config: EdsgerConfig): Promise<ChecklistVerificationResult>;