edsger 0.2.1 → 0.2.2

package/dist/{feature-analysis → phases/feature-analysis}/analyzer.js

@@ -1,7 +1,12 @@
 import { query } from '@anthropic-ai/claude-code';
-import { logInfo, logError } from '../logger.js';
+import { logInfo, logError } from '../../utils/logger.js';
 import { saveDataViaHttp } from './http-fallback.js';
-import { fetchFeatureAnalysisContext, createUserStories, createTestCases, formatContextForPrompt, } from './context-fetcher.js';
+import { fetchFeatureAnalysisContext, } from './context-fetcher.js';
+import { createUserStories } from '../../api/features/index.js';
+import { createTestCases } from '../../api/features/index.js';
+import { formatFeatureAnalysisContext } from '../../prompts/formatters.js';
+import { createFeatureAnalysisSystemPrompt, createFeatureAnalysisPromptWithContext, } from '../../prompts/feature-analysis.js';
+import { formatChecklistsForContext, } from '../../services/checklist.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -12,7 +17,7 @@ async function* prompt(analysisPrompt) {
     yield userMessage(analysisPrompt);
     await new Promise((res) => setTimeout(res, 10000));
 }
-export const analyzeFeatureWithMCP = async (options, config) => {
+export const analyzeFeatureWithMCP = async (options, config, checklistContext) => {
     const { featureId, mcpServerUrl, mcpToken, verbose } = options;
     if (verbose) {
         logInfo(`Starting feature analysis for feature ID: ${featureId}`);
@@ -24,8 +29,18 @@ export const analyzeFeatureWithMCP = async (options, config) => {
             logInfo('Fetching feature analysis context via MCP endpoints...');
         }
         const context = await fetchFeatureAnalysisContext(mcpServerUrl, mcpToken, featureId, verbose);
-        const systemPrompt = createSystemPrompt(config);
-        const analysisPrompt = createAnalysisPromptWithContext(featureId, context);
+        const systemPrompt = createFeatureAnalysisSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
+        const contextInfo = formatFeatureAnalysisContext(context);
+        // Add checklist context to the analysis 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 analysis context`);
+            }
+        }
+        const analysisPrompt = createFeatureAnalysisPromptWithContext(featureId, finalContextInfo);
         let lastAssistantResponse = '';
         let structuredAnalysisResult = null;
         if (verbose) {
@@ -120,7 +135,7 @@ export const analyzeFeatureWithMCP = async (options, config) => {
         }
         // Save the analysis results if we have them
         if (structuredAnalysisResult) {
-            const { created_user_stories, created_test_cases, status } = structuredAnalysisResult;
+            const { created_user_stories, created_test_cases, status, checklist_results, checklist_item_results, } = structuredAnalysisResult;
             if (created_user_stories && created_user_stories.length > 0) {
                 if (verbose) {
                     logInfo('Saving created user stories...');
@@ -197,6 +212,10 @@ export const analyzeFeatureWithMCP = async (options, config) => {
                 })),
                 summary: structuredAnalysisResult.summary || 'Analysis completed',
                 status: structuredAnalysisResult.status === 'success' ? 'success' : 'error',
+                data: {
+                    checklist_results,
+                    checklist_item_results,
+                },
             };
         }
         return {
@@ -218,6 +237,10 @@ export const analyzeFeatureWithMCP = async (options, config) => {
             createdTestCases: [],
             summary: 'No analysis results received',
             status: 'error',
+            data: {
+                checklist_results: undefined,
+                checklist_item_results: undefined,
+            },
         };
     }
     catch (error) {
@@ -235,127 +258,6 @@ export const analyzeFeatureWithMCP = async (options, config) => {
         };
     }
 };
-const createSystemPrompt = (_config) => {
-    return `You are an expert product manager and business analyst specializing in feature analysis. Your task is to analyze a feature and generate comprehensive user stories and test cases.
-
-**Your Role**: Conduct business analysis to understand feature requirements and create user stories and test cases that add business value.
-
-CRITICAL: You are NOT a software engineer. You should NEVER write code, build projects, or modify files. Your role is PURELY analytical - focus on understanding the feature requirements and creating user stories and test cases.
-
-**Analysis Process**:
-1. **Review Context**: Analyze the provided feature information, product context, and existing user stories/test cases
-2. **Business Analysis**: Think about different user types, use cases, workflows, and scenarios
-3. **Create User Stories**: Generate new user stories following the "As a [user], I want [goal] so that [benefit]" format
-4. **Design Test Cases**: Create comprehensive test cases covering happy path, edge cases, and error scenarios
-5. **Avoid Duplication**: Ensure new stories and test cases add value without duplicating existing ones
-6. **Provide Results**: Output your analysis in the required JSON format
-
-**Business Analysis Focus**:
-- Understand the feature's business value and user impact
-- Consider different user types (admin, regular user, guest, etc.)
-- Think about user workflows and journeys
-- Consider security, accessibility, and performance implications
-- Think about integration points and dependencies
-- Consider error handling and edge cases
-- Focus on business requirements, not technical implementation
-
-**Important Guidelines**:
-- All feature information, product context, and existing user stories/test cases are provided in the prompt
-- Do NOT attempt to read source code files or run any commands
-- Do NOT use tools like Bash, Read, Glob, Write, TodoWrite, or any other tools
-- Focus on creating valuable user stories and comprehensive test cases
-- Avoid duplicating existing user stories and test cases
-- Consider different user perspectives and scenarios
-
-**CRITICAL - Result Format**:
-You MUST end your response with a JSON object containing the analysis results in this EXACT format:
-
-\`\`\`json
-{
-  "analysis": {
-    "feature_id": "FEATURE_ID_PLACEHOLDER",
-    "status": "success",
-    "summary": "Brief summary of analysis and what was accomplished",
-    "created_user_stories": [
-      {
-        "title": "User story title",
-        "description": "As a [user], I want [goal] so that [benefit]",
-        "status": "draft"
-      }
-    ],
-    "created_test_cases": [
-      {
-        "name": "Test case name",
-        "description": "Detailed test case description with steps and expected outcomes",
-        "is_critical": true
-      }
-    ],
-    "recommendations": "Additional recommendations for the feature"
-  }
-}
-\`\`\`
-
-**Quality Guidelines**:
-- User stories should be clear, concise, and user-focused
-- Test cases should be comprehensive and cover all scenarios
-- Consider accessibility, security, and performance aspects
-- Think about different user types and permissions
-- Include both happy path and error scenarios
-- Focus on business value and user experience
-
-Focus on systematic analysis based on the provided context information.`;
-};
-const createAnalysisPromptWithContext = (featureId, context) => {
-    const contextInfo = formatContextForPrompt(context);
-    return `Please conduct comprehensive business analysis for feature ID: ${featureId}
-
-${contextInfo}
-
-## Analysis Instructions
-
-Follow this systematic approach:
-
-1. **Review Feature Context**: Analyze the feature information, product context, and technical design above
-
-2. **Review Existing Items**: Study the existing user stories and test cases to understand:
-   - What scenarios are already covered
-   - What user perspectives are already addressed
-   - Where gaps might exist
-
-3. **Business Analysis**: Think about the feature from a business perspective:
-   - Who are the different types of users?
-   - What problems does this feature solve?
-   - What are the different use cases and user workflows?
-   - What edge cases and error scenarios might occur?
-   - How does this integrate with other features?
-
-4. **Create New User Stories**: Generate user stories that ADD VALUE by covering:
-   - Different user types or personas not yet covered
-   - New use cases or workflows
-   - Edge cases or error scenarios
-   - Different permission levels or access patterns
-   - Integration scenarios
-
-5. **Design Test Cases**: Create test cases that ensure comprehensive coverage:
-   - Happy path scenarios
-   - Edge cases and boundary conditions
-   - Error handling and validation
-   - Security and permission testing
-   - Performance and usability aspects
-   - Integration testing scenarios
-
-6. **Provide Results**: Output your analysis in the required JSON format
-
-## Important Notes
-- Focus on creating NEW user stories and test cases that add business value
-- Avoid duplicating existing user stories and test cases
-- Consider different user types (admin, regular user, guest, etc.)
-- Think about accessibility, security, and performance implications
-- The feature should already have some design - you're analyzing business requirements
-- Be thorough but focus on practical, testable scenarios
-
-Begin your systematic analysis based on the above context.`;
-};
 export const checkFeatureAnalysisRequirements = async () => {
     try {
         // Check if Claude Code SDK is available

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

@@ -0,0 +1,18 @@
+import { createUserStories, createTestCases } from '../../api/features/index.js';
+import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
+import { type ProductInfo } from '../../api/products.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(mcpServerUrl: string, mcpToken: string, 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;

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

@@ -0,0 +1,86 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature, getUserStories, createUserStories, getTestCases, createTestCases, } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+/**
+ * Fetch all feature analysis context information via MCP endpoints
+ */
+export async function fetchFeatureAnalysisContext(mcpServerUrl, mcpToken, 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(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(`✅ 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.`;
+}

package/dist/{feature-analysis → phases/feature-analysis}/http-fallback.js

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../logger.js';
+import { logInfo, logError } from '../../utils/logger.js';
 export async function saveDataViaHttp(options) {
     const { mcpServerUrl, mcpToken, featureId, userStories, testCases, verbose } = options;
     if (verbose) {

package/dist/{feature-analysis → phases/feature-analysis}/mcp-server.js

@@ -1,29 +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) {
-    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;
-}
+import { callMcpEndpoint } from '../../api/mcp-client.js';
 // Create an SDK MCP server with custom tools for product management
 export const createProductMcpServer = (mcpServerUrl, mcpToken) => {
     return createSdkMcpServer({

package/dist/{functional-testing → phases/functional-testing}/analyzer.d.ts

@@ -1,4 +1,5 @@
-import { EdsgerConfig } from '../types.js';
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
 import { type TestReportResult } from './test-report-creator.js';
 export interface FunctionalTestingOptions {
     mcpServerUrl: string;
@@ -21,6 +22,12 @@ export interface StructuredTestResult {
     }>;
     execution_details?: string;
     timestamp: string;
+    checklist_item_results?: Array<{
+        checklist_item_id: string;
+        is_passed: boolean;
+        value?: any;
+        notes?: string;
+    }>;
 }
 export interface FunctionalTestingResult {
     featureId: string;
@@ -29,6 +36,14 @@ export interface FunctionalTestingResult {
     testReport?: TestReportResult;
     status: 'success' | 'error';
     message: string;
+    data?: {
+        checklist_item_results?: Array<{
+            checklist_item_id: string;
+            is_passed: boolean;
+            value?: any;
+            notes?: string;
+        }>;
+    };
 }
-export declare const runFunctionalTesting: (options: FunctionalTestingOptions, config: EdsgerConfig) => Promise<FunctionalTestingResult>;
+export declare const runFunctionalTesting: (options: FunctionalTestingOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<FunctionalTestingResult>;
 export declare function checkFunctionalTestingRequirements(): Promise<boolean>;