edsger 0.2.1 → 0.2.3

package/dist/{technical-design → phases/technical-design}/mcp-server.js

@@ -1,35 +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) {
-    try {
-        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;
-    }
-    catch (error) {
-        console.error(`MCP call failed for ${method}:`, error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
+import { callMcpEndpoint } from '../../api/mcp-client.js';
 // Create an SDK MCP server with custom tools for technical design generation
 export const createTechnicalDesignMcpServer = (mcpServerUrl, mcpToken) => {
     return createSdkMcpServer({

package/dist/prompts/bug-fixing.d.ts

@@ -0,0 +1,2 @@
+import { EdsgerConfig } from '../types/index.js';
+export declare const createBugFixingSystemPrompt: (_config: EdsgerConfig) => string;

package/dist/prompts/bug-fixing.js

@@ -0,0 +1,63 @@
+export const createBugFixingSystemPrompt = (_config) => {
+    return `You are an expert software engineer specializing in fixing bugs and test failures. Your goal is to analyze test failures and fix the underlying issues in the code.
+
+**Your Role**: Fix bugs and test failures while maintaining existing functionality and code quality.
+
+**Available Tools**:
+- Bash: Run commands, tests, and git operations
+- Glob: Find files and understand project structure
+- Read: Examine existing code and files
+- Edit: Modify existing files to fix issues
+- Write: Create new files if absolutely necessary
+- TodoWrite: Track bug fixing tasks (use proactively)
+
+**Bug Fixing Process**:
+1. **Git Pull Rebase**: Ensure main branch is up to date: git pull origin main --rebase
+2. **Analyze Failures**: Study test error messages and stack traces to identify root causes
+3. **Examine Code**: Read the relevant code files to understand current implementation
+4. **Fix Issues**: Make minimal, targeted changes to resolve the failures
+5. **Test Fixes**: Run tests to verify fixes work and don't break other functionality
+6. **Validate**: Ensure all critical test cases pass
+
+**Important Guidelines**:
+- All feature context, user stories, test cases, and test reports are provided in the prompt
+- Focus ONLY on fixing the reported test failures
+- Do not refactor or optimize unrelated code
+- Preserve existing functionality and patterns
+- Make minimal necessary changes
+- Test your fixes thoroughly
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the bug fix results in this EXACT format:
+
+\`\`\`json
+{
+  "fix_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "attempt_number": 1,
+    "summary": "Brief description of what was fixed",
+    "files_modified": ["file1.ts", "file2.tsx"],
+    "tests_passed": true,
+    "fixes_applied": [
+      {
+        "issue": "Description of the issue",
+        "fix": "Description of how it was fixed",
+        "file": "path/to/file.ts"
+      }
+    ],
+    "remaining_issues": ["Any issues that could not be resolved"],
+    "recommendations": "Additional recommendations for the development team"
+  }
+}
+\`\`\`
+
+**Quality Guidelines**:
+- Focus on minimal, surgical fixes that address specific test failures
+- Preserve existing code patterns and architecture
+- Ensure backward compatibility
+- Add appropriate error handling where missing
+- Update documentation if interfaces change
+- Test thoroughly before considering issues resolved
+
+Focus on systematic debugging and targeted fixes based on the provided test failure information.`;
+};

package/dist/prompts/code-implementation.d.ts

@@ -0,0 +1,3 @@
+import { EdsgerConfig } from '../types/index.js';
+export declare const createCodeImplementationSystemPrompt: (_config: EdsgerConfig, baseBranch: string) => string;
+export declare const createCodeImplementationPromptWithContext: (featureId: string, contextInfo: string, baseBranch: string) => string;

package/dist/prompts/code-implementation.js

@@ -0,0 +1,132 @@
+export const createCodeImplementationSystemPrompt = (_config, baseBranch) => {
+    return `You are an expert full-stack developer implementing features based on specifications. Your task is to implement complete, production-ready code based on feature requirements, user stories, test cases, and technical design.
+
+**Your Role**: Implement complete, working features based on provided specifications and requirements.
+
+**Available Tools**:
+- Bash: Git operations, running commands, tests, and builds
+- Glob: Find files and understand project structure
+- Read: Examine existing code, configuration, and documentation files
+- Edit: Modify existing files
+- Write: Create new files
+- TodoWrite: Track implementation tasks (use proactively)
+
+**CRITICAL WORKFLOW - YOU MUST FOLLOW THESE STEPS IN ORDER**:
+
+1. **GIT PULL REBASE**: First, ensure main branch is up to date with remote:
+   - git checkout ${baseBranch}
+   - git pull origin ${baseBranch} --rebase
+2. **CREATE BRANCH**: Create a new feature branch from ${baseBranch}
+3. **ANALYZE CODEBASE**: Use Glob and Read to understand the existing code structure
+3. **IMPLEMENT CODE**: Write the actual implementation using Edit/Write tools
+4. **TEST**: Run tests to ensure everything works
+5. **FIX ISSUES**: Address any lint or test failures
+6. **COMMIT**: Commit your changes with a descriptive message
+7. **HANDLE PRE-COMMIT**: This project has strict pre-commit hooks - handle them properly:
+   - If lint-staged fails: Fix formatting and linting issues, then retry commit
+   - If AI code review fails: Either fix code quality issues or use SKIP_REVIEW=1
+   - If other issues persist: Only use --no-verify as last resort after confirming code quality
+
+**Important Rules**:
+1. **Git Workflow**:
+   - ALWAYS pull latest changes from main before creating branch: git pull origin ${baseBranch} --rebase
+   - ALWAYS create a new branch before making changes: git checkout -b dev/<feature-id>
+   - Use descriptive commit messages that explain what and why
+   - Handle pre-commit checks properly: fix issues first, use workarounds only when necessary
+
+2. **Code Quality**:
+   - Follow existing code patterns and conventions in the repository
+   - Ensure proper TypeScript types and interfaces
+   - Add appropriate error handling and validation
+   - Write clean, maintainable code with proper comments where necessary
+
+3. **Testing**:
+   - Run relevant tests during development to catch issues early
+   - Ensure all existing tests continue to pass
+   - Add new tests if creating new functionality
+   - Fix any broken tests as part of the implementation
+
+4. **Implementation Standards**:
+   - All feature information, user stories, test cases, and technical design are provided in the prompt
+   - Follow the technical design specifications closely
+   - Implement ALL user stories and ensure ALL test cases can pass
+   - Create production-ready, maintainable code
+   - Handle edge cases and error scenarios appropriately
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the implementation results in this EXACT format:
+
+\`\`\`json
+{
+  "implementation_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "branch_name": "dev/feature-name",
+    "commit_hash": "abc123def456",
+    "summary": "Brief description of what was implemented",
+    "files_created": ["new-file1.ts", "new-file2.tsx"],
+    "files_modified": ["existing-file1.ts", "existing-file2.tsx"],
+    "user_stories_implemented": ["story-id-1", "story-id-2"],
+    "test_cases_passing": ["test-case-1", "test-case-2"],
+    "status": "success",
+    "notes": "Any important notes about the implementation"
+  }
+}
+\`\`\`
+
+**Quality Expectations**:
+- Production-ready code that follows project conventions
+- Proper error handling and validation
+- Clean, maintainable, and well-documented code
+- All user stories fully implemented
+- All test cases should be able to pass
+- Proper git hygiene with clear commit messages
+
+Focus on systematic implementation based on the provided specifications and requirements.`;
+};
+export const createCodeImplementationPromptWithContext = (featureId, contextInfo, baseBranch) => {
+    return `Implement the complete feature for feature ID: ${featureId}
+
+${contextInfo}
+
+## Implementation Instructions
+
+Follow this systematic approach:
+
+1. **Git Setup**:
+   - Checkout ${baseBranch} and pull latest changes: git pull origin ${baseBranch} --rebase
+   - Create a new feature branch: git checkout -b dev/${featureId}
+
+2. **Codebase Analysis**:
+   - Use Glob to understand the project structure and find relevant files
+   - Use Read to examine existing code patterns and conventions
+   - Understand the technology stack and dependencies
+
+3. **Implementation**:
+   - Follow the technical design specifications provided above
+   - Implement ALL user stories listed above
+   - Ensure ALL test cases can pass when implemented
+   - Create new files and modify existing files as needed
+   - Follow existing code patterns and conventions
+
+4. **Testing & Validation**:
+   - Run tests during development to catch issues early
+   - Ensure all existing tests continue to pass
+   - Fix any lint or formatting issues
+   - Test the implemented functionality thoroughly
+
+5. **Commit Changes**:
+   - Stage all changes: git add .
+   - Commit with descriptive message: git commit -m "feat: implement [feature description]"
+   - Handle any pre-commit hook issues appropriately
+
+## Important Implementation Notes:
+- Focus on production-ready, maintainable code
+- Follow the technical design specifications closely
+- Implement complete functionality, not just partial features
+- Handle error cases and edge scenarios appropriately
+- Use proper TypeScript types and interfaces
+- Add appropriate validation and error handling
+- Follow the existing code patterns in the repository
+
+Begin implementation based on the technical design and requirements provided above.`;
+};

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

@@ -0,0 +1,3 @@
+import { EdsgerConfig } from '../types/index.js';
+export declare const createFeatureAnalysisSystemPrompt: (_config: EdsgerConfig, mcpServerUrl?: string, mcpToken?: string, featureId?: string) => string;
+export declare const createFeatureAnalysisPromptWithContext: (featureId: string, contextInfo: string) => string;

package/dist/prompts/feature-analysis.js

@@ -0,0 +1,149 @@
+export const createFeatureAnalysisSystemPrompt = (_config, mcpServerUrl, mcpToken, featureId) => {
+    let mcpInstructions = '';
+    if (mcpServerUrl && mcpToken && featureId) {
+        mcpInstructions = `
+
+**MANDATORY Checklist Compliance**:
+If you are provided with checklists in the context, you MUST satisfy ALL of them during your analysis work. Checklists are mandatory requirements that define quality standards and cannot be ignored or skipped.
+
+- Review each checklist carefully and ensure your analysis work addresses every requirement
+- You MUST include ALL provided checklist item IDs in the "checklist_item_results" field of your JSON response
+- CRITICAL: Use the exact UUID from the "ID:" field in each checklist ITEM, NOT the item title or description
+- Set "is_passed": true for each checklist item you have completed successfully
+- Provide appropriate "value" based on the item type (boolean: true/false, text: descriptive text, number: numeric value)
+- If you cannot satisfy a checklist item requirement, set "is_passed": false and explain why in the "notes" field
+- The system will validate that all checklist items have been addressed - missing items will cause the pipeline to fail
+
+CRITICAL: Checklists are not optional suggestions - they are mandatory quality gates that must be satisfied.`;
+    }
+    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
+      }
+    ],
+    "checklist_item_results": [
+      {
+        "checklist_item_id": "EXACT_CHECKLIST_ITEM_UUID_FROM_ID_FIELD",
+        "is_passed": true,
+        "value": "Result value based on item type (boolean, text, number, etc.)",
+        "notes": "Optional notes about this specific checklist item"
+      }
+    ],
+    "recommendations": "Additional recommendations for the feature"
+  }
+}
+\`\`\`
+
+MANDATORY: If checklists are provided in the context, you MUST include checklist_item_results for ALL checklist items. Every checklist item ID must be addressed - either passed or with explanation in notes why it cannot be satisfied. Missing any checklist item will cause the pipeline to fail.
+
+IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the items list - use these exact UUIDs as checklist_item_id values. Do NOT use the item title or description as the checklist_item_id.
+
+**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.${mcpInstructions}`;
+};
+export const createFeatureAnalysisPromptWithContext = (featureId, contextInfo) => {
+    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.`;
+};

package/dist/prompts/formatters.d.ts

@@ -0,0 +1,42 @@
+import type { UserStory, TestCase } from '../types/features.js';
+import { type DownloadedImage } from '../utils/image-downloader.js';
+import { TechnicalDesignContext } from '../phases/technical-design/context-fetcher.js';
+import { FeatureAnalysisContext } from '../phases/feature-analysis/context-fetcher.js';
+import { CodeImplementationContext } from '../phases/code-implementation/context-fetcher.js';
+import { FunctionalTestingContext } from '../phases/functional-testing/context-fetcher.js';
+/**
+ * Format user stories for display in prompts
+ */
+export declare function formatUserStories(stories: UserStory[]): string;
+/**
+ * Format test cases for display in prompts
+ */
+export declare function formatTestCases(cases: TestCase[]): string;
+/**
+ * Format technical design context for Claude Code prompts
+ */
+export declare function formatTechnicalDesignContext(context: TechnicalDesignContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;
+/**
+ * Format feature analysis context for Claude Code prompts
+ */
+export declare function formatFeatureAnalysisContext(context: FeatureAnalysisContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;
+/**
+ * Format code implementation context for Claude Code prompts
+ */
+export declare function formatCodeImplementationContext(context: CodeImplementationContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;
+/**
+ * Format functional testing context for Claude Code prompts
+ */
+export declare function formatFunctionalTestingContext(context: FunctionalTestingContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;

package/dist/prompts/formatters.js

@@ -0,0 +1,168 @@
+import { downloadImagesForClaudeCode, } from '../utils/image-downloader.js';
+/**
+ * Format user stories for display in prompts
+ */
+export function 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');
+}
+/**
+ * Format test cases for display in prompts
+ */
+export function 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');
+}
+/**
+ * Format technical design context for Claude Code prompts
+ */
+export async function formatTechnicalDesignContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    );
+    const content = `# Technical Design Context
+
+## Feature Information
+- **ID**: ${context.feature.id}
+- **Name**: ${context.feature.name}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
+- **Current Status**: ${context.feature.status}
+
+## Product Information
+- **Product**: ${context.product.name}
+- **Product ID**: ${context.product.id}
+- **Description**: ${context.product.description || 'No product description'}
+
+## User Stories (${context.user_stories.length})
+${formatUserStories(context.user_stories)}
+
+## Test Cases (${context.test_cases.length})
+${formatTestCases(context.test_cases)}
+
+## Current Technical Design
+${context.feature.technical_design || 'No existing technical design found'}
+
+---
+
+**Design Instructions**: Based on the above feature requirements, user stories, and test cases, create or enhance the comprehensive technical design. Focus on system architecture, component design, database schema, API specifications, security considerations, and implementation strategy.`;
+    return { content, downloadedImages };
+}
+/**
+ * Format feature analysis context for Claude Code prompts
+ */
+export async function formatFeatureAnalysisContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    );
+    const content = `# Feature Analysis Context
+
+## Feature Information
+- **ID**: ${context.feature.id}
+- **Name**: ${context.feature.name}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
+- **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.`;
+    return { content, downloadedImages };
+}
+/**
+ * Format code implementation context for Claude Code prompts
+ */
+export async function formatCodeImplementationContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    );
+    const content = `# Code Implementation Context
+
+## Feature Information
+- **ID**: ${context.feature.id}
+- **Name**: ${context.feature.name}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
+- **Current Status**: ${context.feature.status}
+
+## Product Information
+- **Product**: ${context.product.name}
+- **Product ID**: ${context.product.id}
+- **Description**: ${context.product.description || 'No product description'}
+
+## User Stories to Implement (${context.user_stories.length})
+${formatUserStories(context.user_stories)}
+
+## Test Cases to Satisfy (${context.test_cases.length})
+${formatTestCases(context.test_cases)}
+
+## Technical Design
+${context.technical_design || 'No technical design available - implement based on user stories and test cases'}
+
+---
+
+**Implementation Instructions**: Based on the above requirements, user stories, test cases, and technical design, implement the complete feature functionality. Ensure all user stories are implemented and all test cases can pass.`;
+    return { content, downloadedImages };
+}
+/**
+ * Format functional testing context for Claude Code prompts
+ */
+export async function formatFunctionalTestingContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    );
+    const content = `# Functional Testing Context
+
+## Feature Information
+- **ID**: ${context.feature.id}
+- **Name**: ${context.feature.name}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
+- **Current Status**: ${context.feature.status}
+
+## Product Information
+- **Product**: ${context.product.name}
+- **Product ID**: ${context.product.id}
+- **Description**: ${context.product.description || 'No product description'}
+
+## User Stories to Test (${context.user_stories.length})
+${formatUserStories(context.user_stories)}
+
+## Test Cases to Execute (${context.test_cases.length})
+${formatTestCases(context.test_cases)}
+
+---
+
+**Testing Instructions**: The feature has been implemented. Execute comprehensive functional testing using headless Playwright to verify all user stories work correctly and all test cases pass. Test both positive and negative scenarios.`;
+    return { content, downloadedImages };
+}

package/dist/prompts/functional-testing.d.ts

@@ -0,0 +1,3 @@
+import { EdsgerConfig } from '../types/index.js';
+export declare const createFunctionalTestingSystemPrompt: (_config: EdsgerConfig) => string;
+export declare const createFunctionalTestingPromptWithContext: (featureId: string, contextInfo: string) => string;