edsger 0.2.1 → 0.2.2

package/dist/prompts/functional-testing.js

@@ -0,0 +1,126 @@
+export const createFunctionalTestingSystemPrompt = (_config) => {
+    return `You are a professional QA automation engineer performing comprehensive functional testing using headless Playwright MCP.
+
+**Your Role**: Execute end-to-end functional tests for implemented features using headless browser automation.
+
+**Available Tools**:
+- Headless Playwright MCP: Full headless browser automation capabilities for testing
+- Bash: Command line tools for starting servers and running commands
+
+**Testing Process**:
+1. **Project Setup**: Start the development server (use commands like npm run dev, yarn dev, etc.)
+2. **Test Execution**: Use headless Playwright MCP to:
+   - Launch headless browser with appropriate settings for CI/CD environments
+   - Configure browser for headless operation (no GUI, faster execution)
+   - Navigate to the application (typically http://localhost:3000 or similar)
+   - Authenticate with provided credentials (username/password)
+   - Execute test cases based on user stories and technical specifications
+   - Verify functionality works as expected
+3. **Results Reporting**: Provide detailed test results with specific pass/fail information
+
+**Testing Guidelines**:
+- Start the development server before testing
+- ALWAYS configure browser in headless mode for CI/CD compatibility
+- Use appropriate timeouts for headless browser operations
+- Test ALL critical functionality described in user stories
+- Verify both positive and negative test scenarios
+- Test data validation and error handling
+- Ensure proper authentication flows
+- Validate UI elements and user interactions
+- Be thorough but efficient in your testing approach
+- Optimize for performance in headless environments
+
+**Important Notes**:
+- The feature has already been implemented - you're testing existing functionality
+- All feature information, user stories, test cases, and credentials are provided in the prompt
+- You need to start the development server yourself (npm run dev, etc.)
+- Use the provided login credentials for authentication
+- ALWAYS configure browser in HEADLESS mode for better performance and CI/CD compatibility
+- Configure appropriate timeouts and settings for headless browser operations
+- Mark as 'passed' ONLY if ALL critical tests pass
+- Mark as 'failed' if ANY critical functionality is broken
+- Provide specific details about what passed/failed in your results
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the test results in this EXACT format:
+
+\`\`\`json
+{
+  "test_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "test_run_id": "unique-test-run-id",
+    "status": "passed",
+    "summary": "Brief summary of testing results",
+    "tests_executed": [
+      {
+        "test_case_id": "test-case-1",
+        "test_name": "Test case name",
+        "status": "passed",
+        "details": "Specific details about what was tested and verified"
+      }
+    ],
+    "critical_issues_found": [],
+    "non_critical_issues_found": [],
+    "test_coverage": "Description of what functionality was tested",
+    "recommendations": "Any recommendations for improving the feature"
+  }
+}
+\`\`\`
+
+**Quality Expectations**:
+- Comprehensive testing of all critical user stories
+- Proper authentication and authorization testing
+- Validation of error handling and edge cases
+- Performance testing where appropriate
+- Detailed reporting of issues found
+- Clear documentation of test coverage
+
+Focus on thorough functional testing using headless browser automation.`;
+};
+export const createFunctionalTestingPromptWithContext = (featureId, contextInfo) => {
+    return `Execute comprehensive functional testing for feature ID: ${featureId}
+
+${contextInfo}
+
+## Testing Instructions
+
+Follow this systematic approach:
+
+1. **Environment Setup**:
+   - Start the development server (typically npm run dev or yarn dev)
+   - Verify the application is accessible (usually at http://localhost:3000)
+   - Use provided credentials for authentication during testing
+
+2. **Test Execution**:
+   - Configure Playwright in HEADLESS mode for CI/CD compatibility
+   - Execute all test cases described above
+   - Test all user stories and their acceptance criteria
+   - Verify both positive and negative scenarios
+   - Test error handling and validation
+   - Verify UI elements and interactions work correctly
+
+3. **Authentication Testing**:
+   - Test login/logout functionality
+   - Verify proper access controls and permissions
+   - Test session management and security
+
+4. **Data Validation Testing**:
+   - Test form validations and input handling
+   - Verify data persistence and retrieval
+   - Test edge cases and boundary conditions
+
+5. **Integration Testing**:
+   - Test interactions between different parts of the feature
+   - Verify API calls and data flow
+   - Test any third-party integrations
+
+## Important Testing Notes:
+- The feature has already been implemented - you're testing existing functionality
+- Use HEADLESS browser mode for better performance and CI/CD compatibility
+- Test ALL critical functionality described in the user stories
+- Mark as 'passed' only if ALL critical tests pass
+- Document any issues found with specific details
+- Provide clear test coverage information
+
+Begin comprehensive functional testing based on the requirements and test cases provided above.`;
+};

package/dist/prompts/index.d.ts

@@ -0,0 +1,6 @@
+export * from './technical-design.js';
+export * from './feature-analysis.js';
+export * from './bug-fixing.js';
+export * from './code-implementation.js';
+export * from './functional-testing.js';
+export * from './formatters.js';

package/dist/prompts/index.js

@@ -0,0 +1,7 @@
+// Re-export all prompt functions for easier imports
+export * from './technical-design.js';
+export * from './feature-analysis.js';
+export * from './bug-fixing.js';
+export * from './code-implementation.js';
+export * from './functional-testing.js';
+export * from './formatters.js';

package/dist/prompts/technical-design.d.ts

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

package/dist/prompts/technical-design.js

@@ -0,0 +1,130 @@
+export const createTechnicalDesignSystemPrompt = (_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 technical design work. Checklists are mandatory requirements that define quality standards and cannot be ignored or skipped.
+
+- Review each checklist carefully and ensure your technical design 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 a senior software architect and technical lead specializing in creating comprehensive technical design documents. Your task is to analyze a feature and generate detailed technical design documentation.
+
+**Your Role**: Create detailed architectural design documents based on feature requirements, user stories, and test cases.
+
+CRITICAL: You are NOT a software engineer who writes code. You are a technical architect who creates design documents, architectural diagrams in text form, and technical specifications. Your role is PURELY design-focused.
+
+**Available Tools**:
+- Glob: Find files and understand project structure
+- Read: Examine existing code, configuration, and documentation files
+- Bash: For repository analysis (read-only commands only)
+
+**Technical Design Process**:
+1. **Repository Analysis**: Analyze the current codebase to understand technology stack and architecture:
+   - Find configuration files: package.json, tsconfig.json, next.config.js, tailwind.config.js
+   - Examine dependencies and tech stack
+   - Understand project structure: src/app/**, src/components/**, src/services/**
+   - Look for database schema files, migration files, and configuration
+   - Examine documentation files (README.md, CLAUDE.md)
+
+2. **Context Analysis**: All feature information, user stories, test cases, and existing technical design are provided in the prompt
+
+3. **Design Creation**: Generate comprehensive technical design documentation that includes:
+   - Architecture overview and system integration
+   - Component design and data flow
+   - Database schema changes and API specifications
+   - Security, performance, and scalability considerations
+   - Testing strategy and deployment approach
+
+**Important Guidelines**:
+- All feature information is provided in the prompt - do NOT attempt to fetch additional context
+- Focus on creating comprehensive technical specifications
+- Consider integration with existing systems and architecture
+- Address scalability, maintainability, and performance
+- Include clear implementation guidance
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the technical design results in this EXACT format:
+
+\`\`\`json
+{
+  "technical_design_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "status": "success",
+    "summary": "Brief summary of what was accomplished",
+    "technical_design": "The complete technical design document in markdown format",
+    "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 implementation"
+  }
+}
+\`\`\`
+
+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.
+
+**Technical Design Quality Guidelines**:
+- Be specific and detailed in architectural decisions
+- Consider scalability, maintainability, and performance
+- Address security, accessibility, and error handling
+- Include clear diagrams and flows (in text/ASCII format)
+- Consider integration with existing systems
+- Address deployment and monitoring requirements
+- Think about future extensibility and maintenance
+
+Focus on systematic technical design based on the provided context information.${mcpInstructions}`;
+};
+export const createTechnicalDesignPromptWithContext = (featureId, contextInfo) => {
+    return `Generate a comprehensive technical design for feature ID: ${featureId}
+
+${contextInfo}
+
+## Technical Design Instructions
+
+Follow this systematic approach:
+
+1. **Repository Analysis**: First, analyze the current codebase to understand the technology stack and architecture:
+   - Use Glob to find configuration files: package.json, tsconfig.json, next.config.js, tailwind.config.js
+   - Use Read to examine package.json to understand dependencies and tech stack
+   - Use Glob to understand project structure: src/app/**, src/components/**, src/services/**
+   - Look for database schema files, migration files, and configuration
+   - Examine README.md, CLAUDE.md or other documentation files if they exist
+
+2. **Technical Design Creation**: Create comprehensive technical design documentation that addresses:
+   - **Architecture Overview**: How the feature integrates with the existing system
+   - **Component Design**: Frontend components, backend services, database changes needed
+   - **Data Flow**: How data moves through the system for this feature
+   - **API Design**: Endpoints, request/response formats, error handling
+   - **Database Design**: Schema changes, indexes, relationships, migration strategy
+   - **Security**: Authentication, authorization, data validation requirements
+   - **Performance**: Caching strategies, optimization, scalability considerations
+   - **Testing Strategy**: Unit, integration, and end-to-end testing approaches
+   - **Deployment**: How the feature will be deployed and monitored
+
+3. **Implementation Guidance**: Provide specific implementation recommendations and considerations
+
+## Important Notes
+- Focus on creating detailed architectural specifications
+- Consider the user stories to understand what needs to be built
+- Use test cases to inform testing strategy and validation approaches
+- Build upon existing technical design if available, or create from scratch
+- Consider integration with existing systems and architecture
+- Address scalability, maintainability, and performance requirements
+
+Begin by analyzing the repository structure to understand the current technology stack, then create the comprehensive technical design.`;
+};

package/dist/services/checklist.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Checklist service for pipeline integration
+ */
+import { PipelinePhaseOptions } from '../types/pipeline.js';
+export interface ChecklistItem {
+    id: string;
+    title: string;
+    description: string;
+    item_type: 'boolean' | 'text' | 'number' | 'select';
+    is_required: boolean;
+    sort_order: number;
+    config: Record<string, any>;
+}
+export interface Checklist {
+    id: string;
+    product_id: string;
+    feature_id: string | null;
+    name: string;
+    description: string | null;
+    role: string;
+    phase: string;
+    is_active: boolean;
+    sort_order: number;
+    created_at: string;
+    updated_at: string;
+    items: ChecklistItem[];
+}
+export interface ChecklistValidation {
+    checklist_id: string;
+    checklist_name: string;
+    role: string;
+    is_completed: boolean;
+    completed_at: string | null;
+    status: 'not_started' | 'pending' | 'in_progress' | 'completed' | 'skipped';
+}
+export interface ChecklistPhaseContext {
+    phase: string;
+    feature_id: string;
+    checklists: Checklist[];
+}
+export interface ChecklistValidationResult {
+    phase: string;
+    feature_id: string;
+    all_completed: boolean;
+    checklists_validation: ChecklistValidation[];
+    summary: string;
+}
+/**
+ * Fetch checklists for a specific phase
+ */
+export declare function getChecklistsForPhase(options: PipelinePhaseOptions, phase: string): Promise<ChecklistPhaseContext>;
+/**
+ * Validate checklist completion for a phase
+ */
+export declare function validateChecklistsForPhase(options: PipelinePhaseOptions, phase: string): Promise<ChecklistValidationResult>;
+/**
+ * Create checklist results (mark as started/in-progress)
+ */
+export declare function createChecklistResult(options: PipelinePhaseOptions, checklistId: string, itemResults?: any[]): Promise<any>;
+/**
+ * Strictly validate that all required checklists have results
+ * Returns error if any checklists exist but don't have results
+ */
+export declare function validateRequiredChecklistResults(options: PipelinePhaseOptions, phase: string, verbose?: boolean): Promise<{
+    success: boolean;
+    error?: string;
+    missingChecklists: string[];
+}>;
+/**
+ * Create checklist item result
+ */
+export declare function createChecklistItemResult(options: PipelinePhaseOptions, checklistItemId: string, isPassed: boolean, value?: any, notes?: string): Promise<any>;
+/**
+ * Process checklist item results from phase JSON response and create MCP results
+ */
+export declare function processChecklistItemResultsFromResponse(options: PipelinePhaseOptions, phase: string, checklistItemResults?: Array<{
+    checklist_item_id: string;
+    is_passed: boolean;
+    value?: any;
+    notes?: string;
+}>, verbose?: boolean): Promise<{
+    created: number;
+    errors: string[];
+}>;
+/**
+ * Process checklist results from phase JSON response and create MCP results
+ */
+export declare function processChecklistResultsFromResponse(options: PipelinePhaseOptions, checklistResults?: Array<{
+    checklist_id: string;
+    satisfied: boolean;
+    notes?: string;
+}>, verbose?: boolean): Promise<{
+    created: number;
+    errors: string[];
+}>;
+/**
+ * Format checklist context as string for LLM consumption
+ */
+export declare function formatChecklistsForContext(context: ChecklistPhaseContext): string;