edsger 0.5.3 → 0.5.4

package/dist/phases/code-implementation/analyzer.js

@@ -374,10 +374,9 @@ CRITICAL: Checklists are not optional suggestions - they are mandatory quality g
 2. **CREATE BRANCH**: Create a new feature branch from ${baseBranch}
 3. **ANALYZE CODEBASE**: Use Glob and Read to understand the existing code structure
 4. **IMPLEMENT CODE**: Write the actual implementation using Edit/Write tools
-5. **TEST**: Run tests to ensure everything works
-6. **FIX ISSUES**: Address any lint or test failures
-7. **COMMIT**: Commit your changes with a descriptive message
-8. **HANDLE PRE-COMMIT**: This project has strict pre-commit hooks - handle them properly:
+5. **FIX ISSUES**: Address any lint or build 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
@@ -395,12 +394,7 @@ CRITICAL: Checklists are not optional suggestions - they are mandatory quality g
    - Add appropriate error handling and validation
    - Write clean, maintainable code with proper comments where necessary
 
-3. **Testing**:
-   - Run existing tests to ensure nothing breaks
-   - Add new tests if implementing new functionality
-   - Ensure all tests pass before committing
-
-4. **Pre-commit Handling**:
+3. **Pre-commit Handling**:
    - This project has strict pre-commit hooks including lint-staged, linting, and AI code review
    - When pre-commit hooks fail, READ the error messages carefully
    - Fix ALL issues reported (lint errors, type errors, formatting, code quality)
@@ -528,12 +522,7 @@ Follow this systematic approach:
    - Following existing code patterns and conventions
    - Adding proper error handling and validation
 
-4. **TEST IMPLEMENTATION**: Run tests to ensure:
-   - All existing tests still pass
-   - New functionality works correctly
-   - Critical test cases are satisfied
-
-5. **COMMIT CHANGES**: Commit your work with a descriptive message
+4. **COMMIT CHANGES**: Commit your work with a descriptive message
    - This project has strict pre-commit hooks (lint-staged, linting, AI code review)
    - If hooks fail, try these approaches in order:
      1. Fix the reported issues (preferred)
@@ -542,10 +531,10 @@ Follow this systematic approach:
 
 ## Important Notes
 - Focus on implementing ALL user stories completely
-- Use the test cases to validate your implementation
 - Follow the technical design if provided, or create your own approach
 - Maintain existing code quality and patterns
 - Never skip pre-commit checks - always fix the issues
+- Focus on implementation only - automated tests will be written in a separate phase
 
 ${checklistInstructions}
 

package/dist/phases/code-implementation/prompts.js

@@ -18,9 +18,8 @@ export const createCodeImplementationSystemPrompt = (_config, 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
+4. **IMPLEMENT CODE**: Write the actual implementation using Edit/Write tools
+5. **FIX ISSUES**: Address any lint or build 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
@@ -40,18 +39,13 @@ export const createCodeImplementationSystemPrompt = (_config, baseBranch) => {
    - 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**:
+3. **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
+   - Implement ALL user stories completely
    - Create production-ready, maintainable code
    - Handle edge cases and error scenarios appropriately
+   - Focus on implementation only - tests will be written in a separate phase
 
 **CRITICAL - Result Format**:
 You MUST end your response with a JSON object containing the implementation results in this EXACT format:
@@ -78,8 +72,8 @@ You MUST end your response with a JSON object containing the implementation resu
 - 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 implementation - automated tests will be written in a separate phase
 
 Focus on systematic implementation based on the provided specifications and requirements.`;
 };
@@ -104,15 +98,12 @@ Follow this systematic approach:
 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
+4. **Validation**:
    - Fix any lint or formatting issues
-   - Test the implemented functionality thoroughly
+   - Ensure the code builds successfully
 
 5. **Commit Changes**:
    - Stage all changes: git add .
@@ -127,6 +118,7 @@ Follow this systematic approach:
 - Use proper TypeScript types and interfaces
 - Add appropriate validation and error handling
 - Follow the existing code patterns in the repository
+- Focus on implementation only - automated tests will be written in a separate phase
 
 Begin implementation based on the technical design and requirements provided above.`;
 };

package/dist/phases/code-testing/analyzer.d.ts

@@ -0,0 +1,22 @@
+import { EdsgerConfig } from '../../types/index.js';
+export interface CodeTestingOptions {
+    featureId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+    verbose?: boolean;
+}
+export interface CodeTestingResult {
+    featureId: string;
+    branchName: string;
+    testSummary: string | null;
+    status: 'success' | 'error';
+    message: string;
+    testFilesCreated?: string[];
+    testFilesModified?: string[];
+    commitHash?: string;
+    totalTestsWritten?: number;
+    testsPassing?: boolean;
+    testCoverage?: string;
+}
+export declare const writeCodeTests: (options: CodeTestingOptions, config: EdsgerConfig) => Promise<CodeTestingResult>;
+export declare const checkCodeTestingRequirements: () => Promise<boolean>;

package/dist/phases/code-testing/analyzer.js

@@ -0,0 +1,224 @@
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';
+import { createCodeTestingSystemPrompt, createCodeTestingPromptWithContext, } from './prompts.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(testingPrompt) {
+    yield userMessage(testingPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+export const writeCodeTests = async (options, config) => {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting code testing phase for feature ID: ${featureId}`);
+        logInfo(`Using MCP server: ${mcpServerUrl}`);
+    }
+    try {
+        // Fetch all required context information via MCP endpoints
+        if (verbose) {
+            logInfo('Fetching code testing context via MCP endpoints...');
+        }
+        const context = await fetchCodeTestingContext(mcpServerUrl, mcpToken, featureId, verbose);
+        const systemPrompt = createCodeTestingSystemPrompt(config);
+        const testingPrompt = createCodeTestingPromptWithContext(featureId, formatContextForPrompt(context));
+        const branchName = `dev/${featureId}`;
+        if (verbose) {
+            logInfo('Starting Claude Code query for code testing...');
+        }
+        let lastAssistantResponse = '';
+        // Execute testing query
+        for await (const message of query({
+            prompt: prompt(testingPrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 3000,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`Received message type: ${message.type}`);
+            }
+            // Stream the testing process
+            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✅ Code testing completed, parsing results...');
+                    try {
+                        const responseText = message.result || lastAssistantResponse;
+                        let jsonResult = null;
+                        // 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 {
+                            jsonResult = JSON.parse(responseText);
+                        }
+                        if (jsonResult && jsonResult.code_test_result) {
+                            const result = jsonResult.code_test_result;
+                            return {
+                                featureId,
+                                branchName: result.branch_name || branchName,
+                                testSummary: result.summary || 'Tests written successfully',
+                                status: 'success',
+                                message: result.summary || 'Code tests written successfully',
+                                testFilesCreated: result.test_files_created || [],
+                                testFilesModified: result.test_files_modified || [],
+                                commitHash: result.commit_hash || '',
+                                totalTestsWritten: result.total_tests_written || 0,
+                                testsPassing: result.tests_passing || false,
+                                testCoverage: result.test_coverage || '',
+                            };
+                        }
+                        else {
+                            throw new Error('Invalid JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse structured test result: ${error}`);
+                        // Fallback parsing
+                        const parsedResult = parseTestingResponse(message.result || lastAssistantResponse, featureId);
+                        return {
+                            featureId,
+                            branchName: parsedResult.branchName,
+                            testSummary: parsedResult.summary || 'Tests written',
+                            status: 'success',
+                            message: parsedResult.summary || 'Code tests written successfully',
+                            testFilesCreated: parsedResult.testFilesCreated,
+                            testFilesModified: parsedResult.testFilesModified,
+                            commitHash: parsedResult.commitHash,
+                        };
+                    }
+                }
+                else {
+                    logError(`\n⚠️  Code testing incomplete: ${message.subtype}`);
+                    if (message.subtype === 'error_max_turns') {
+                        logError('💡 Try breaking down the testing into smaller tasks');
+                    }
+                    // Try to parse results from the last assistant response
+                    if (lastAssistantResponse) {
+                        try {
+                            const responseText = lastAssistantResponse;
+                            let jsonResult = null;
+                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                            if (jsonBlockMatch) {
+                                jsonResult = JSON.parse(jsonBlockMatch[1]);
+                                if (jsonResult && jsonResult.code_test_result) {
+                                    const result = jsonResult.code_test_result;
+                                    return {
+                                        featureId,
+                                        branchName: result.branch_name || branchName,
+                                        testSummary: result.summary || 'Tests partially written',
+                                        status: 'error',
+                                        message: result.summary || 'Code testing incomplete',
+                                        testFilesCreated: result.test_files_created || [],
+                                        testFilesModified: result.test_files_modified || [],
+                                        commitHash: result.commit_hash || '',
+                                    };
+                                }
+                            }
+                        }
+                        catch (error) {
+                            logError(`Failed to parse assistant response: ${error}`);
+                        }
+                    }
+                }
+            }
+        }
+        // If we get here, no valid result was found
+        logError('⚠️  Code testing completed but no structured result found');
+        return {
+            featureId,
+            branchName,
+            testSummary: null,
+            status: 'error',
+            message: 'Code testing completed but could not extract results',
+        };
+    }
+    catch (error) {
+        logError(`Code testing failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            featureId,
+            branchName: `dev/${featureId}`,
+            testSummary: null,
+            status: 'error',
+            message: `Testing failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const parseTestingResponse = (response, featureId) => {
+    console.log('Parsing code testing response...');
+    try {
+        // Try to find JSON in the response
+        const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/) ||
+            response.match(/\{[\s\S]*"code_test_result"[\s\S]*\}/);
+        if (jsonMatch) {
+            const jsonStr = jsonMatch[1] || jsonMatch[0];
+            const parsed = JSON.parse(jsonStr);
+            if (parsed.code_test_result) {
+                const result = parsed.code_test_result;
+                return {
+                    branchName: result.branch_name || `dev/${featureId}`,
+                    testFilesCreated: result.test_files_created || [],
+                    testFilesModified: result.test_files_modified || [],
+                    commitHash: result.commit_hash || '',
+                    summary: result.summary || '',
+                };
+            }
+        }
+        // Fallback: try to extract information from the text
+        const branchMatch = response.match(/branch[:\s]+(\S+)/i);
+        const filesMatch = response.match(/files?[:\s]+([^\n]+)/i);
+        const commitMatch = response.match(/commit[:\s]+([a-f0-9]{7,})/i);
+        return {
+            branchName: branchMatch?.[1] || `dev/${featureId}`,
+            testFilesCreated: filesMatch
+                ? filesMatch[1].split(/[,\s]+/).filter((f) => f)
+                : [],
+            testFilesModified: [],
+            commitHash: commitMatch?.[1] || '',
+            summary: 'Code tests written',
+        };
+    }
+    catch (error) {
+        console.log('Response parsing failed:', error);
+        return {
+            branchName: `dev/${featureId}`,
+            testFilesCreated: [],
+            testFilesModified: [],
+            commitHash: '',
+            summary: 'Code tests written',
+        };
+    }
+};
+export const checkCodeTestingRequirements = async () => {
+    try {
+        // Check if Claude Code SDK is available
+        const claudeCode = await import('@anthropic-ai/claude-code');
+        return claudeCode && typeof claudeCode.query === 'function';
+    }
+    catch (error) {
+        console.log('Code testing requirements check failed:', error instanceof Error ? error.message : error);
+        return false;
+    }
+};

package/dist/phases/code-testing/context-fetcher.d.ts

@@ -0,0 +1,16 @@
+import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
+import { type ProductInfo } from '../../api/products.js';
+export interface CodeTestingContext {
+    feature: FeatureInfo;
+    product: ProductInfo;
+    user_stories: UserStory[];
+    test_cases: TestCase[];
+}
+/**
+ * Fetch all code testing context information via MCP endpoints
+ */
+export declare function fetchCodeTestingContext(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<CodeTestingContext>;
+/**
+ * Format the context into a readable string for Claude Code
+ */
+export declare function formatContextForPrompt(context: CodeTestingContext): string;

package/dist/phases/code-testing/context-fetcher.js

@@ -0,0 +1,81 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature, getUserStories, getTestCases, } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+/**
+ * Fetch all code testing context information via MCP endpoints
+ */
+export async function fetchCodeTestingContext(mcpServerUrl, mcpToken, featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching complete code testing context for feature: ${featureId}`);
+        }
+        // Fetch all required data in parallel for better performance
+        const [feature, user_stories, 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(`✅ Code testing context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   User Stories: ${user_stories.length}`);
+            logInfo(`   Test Cases: ${test_cases.length}`);
+        }
+        return {
+            feature,
+            product,
+            user_stories,
+            test_cases,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch code testing context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}
+/**
+ * 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 `# Code Testing 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'}
+
+## User Stories (${context.user_stories.length})
+${formatUserStories(context.user_stories)}
+
+## Test Cases (${context.test_cases.length})
+${formatTestCases(context.test_cases)}
+
+---
+
+**Testing Instructions**: The feature has been implemented. Write comprehensive automated tests (unit tests, integration tests, etc.) for all implemented functionality based on the user stories and test cases provided above.`;
+}

package/dist/phases/code-testing/index.d.ts

@@ -0,0 +1,2 @@
+export { writeCodeTests, checkCodeTestingRequirements, type CodeTestingOptions, type CodeTestingResult, } from './analyzer.js';
+export { fetchCodeTestingContext, formatContextForPrompt, type CodeTestingContext, } from './context-fetcher.js';

package/dist/phases/code-testing/index.js

@@ -0,0 +1,2 @@
+export { writeCodeTests, checkCodeTestingRequirements, } from './analyzer.js';
+export { fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';

package/dist/phases/code-testing/prompts.d.ts

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

package/dist/phases/code-testing/prompts.js

@@ -0,0 +1,144 @@
+export const createCodeTestingSystemPrompt = (_config) => {
+    return `You are an expert test engineer specializing in writing comprehensive automated tests. Your task is to write tests for the implemented code based on feature specifications.
+
+**Your Role**: Write comprehensive automated tests (unit tests, integration tests, etc.) for the implemented feature based on requirements, user stories, and technical design.
+
+**Available Tools**:
+- Bash: Git operations, running tests, and commands
+- Glob: Find files and understand project structure
+- Read: Examine existing code and tests
+- Edit: Modify existing test files
+- Write: Create new test files
+- TodoWrite: Track testing tasks (use proactively)
+
+**CRITICAL WORKFLOW - YOU MUST FOLLOW THESE STEPS IN ORDER**:
+
+1. **GIT CHECKOUT**: Checkout the feature branch that contains the implementation
+2. **ANALYZE CODE**: Use Glob and Read to understand:
+   - The implemented code structure
+   - Existing test patterns and frameworks
+   - Test utilities and helpers available
+   - What needs to be tested
+3. **WRITE TESTS**: Create comprehensive automated tests:
+   - Unit tests for individual functions and methods
+   - Integration tests for component interactions
+   - Test edge cases and error conditions
+   - Test data validation and transformations
+   - Follow existing test patterns
+4. **RUN TESTS**: Execute tests to ensure they work correctly
+5. **FIX ISSUES**: Address any failing tests or issues
+6. **COMMIT**: Commit your test files with a descriptive message
+
+**Important Rules**:
+1. **Git Workflow**:
+   - Checkout the feature branch (dev/<feature-id>)
+   - Work on the same branch as the implementation
+   - Use descriptive commit messages for test changes
+
+2. **Testing Standards**:
+   - Write clear, focused tests
+   - Follow existing test patterns and conventions
+   - Use appropriate test frameworks (Jest, Vitest, etc.)
+   - Write descriptive test names that explain what is being tested
+   - Use proper arrange-act-assert patterns
+   - Mock external dependencies appropriately
+   - Write both unit tests and integration tests as needed
+
+3. **Test Coverage**:
+   - Test all critical functionality
+   - Include positive and negative test cases
+   - Test edge cases and boundary conditions
+   - Test error handling and validation
+   - Aim for high code coverage of critical paths
+   - Test component interactions and integrations
+
+4. **Code Quality**:
+   - Follow project testing conventions
+   - Write maintainable, readable tests
+   - Avoid test duplication
+   - Keep tests focused and isolated
+   - Ensure tests are deterministic and reliable
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the test results in this EXACT format:
+
+\`\`\`json
+{
+  "code_test_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "branch_name": "dev/feature-name",
+    "commit_hash": "abc123def456",
+    "summary": "Brief description of tests written",
+    "test_files_created": ["test-file1.test.ts", "test-file2.test.tsx"],
+    "test_files_modified": ["existing-test1.test.ts"],
+    "total_tests_written": 25,
+    "tests_passing": true,
+    "test_coverage": "Description of what functionality is covered by tests",
+    "status": "success",
+    "notes": "Any important notes about the tests"
+  }
+}
+\`\`\`
+
+**Quality Expectations**:
+- Comprehensive test coverage of implemented functionality
+- Clear, maintainable test code
+- All tests passing
+- Proper use of test frameworks and utilities
+- Good documentation of test scenarios
+- Mix of unit and integration tests as appropriate
+
+Focus on writing high-quality automated tests that verify the implementation works correctly.`;
+};
+export const createCodeTestingPromptWithContext = (featureId, contextInfo) => {
+    return `Write comprehensive automated tests for feature ID: ${featureId}
+
+${contextInfo}
+
+## Testing Instructions
+
+Follow this systematic approach:
+
+1. **Git Setup**:
+   - Checkout the feature branch: git checkout dev/${featureId}
+   - Ensure you're on the correct branch with the implementation
+
+2. **Code Analysis**:
+   - Use Glob to find the implemented files
+   - Use Read to understand the code that needs testing
+   - Identify all functions, methods, and components to test
+   - Review existing test patterns in the codebase
+
+3. **Write Automated Tests**:
+   - Create test files following project conventions
+   - Write unit tests for individual functions and methods
+   - Write integration tests for component interactions
+   - Include tests for:
+     - Happy path scenarios
+     - Edge cases and boundary conditions
+     - Error handling and validation
+     - Data transformations
+     - Component interactions
+   - Use appropriate mocking for dependencies
+   - Follow existing test patterns and conventions
+
+4. **Run and Verify Tests**:
+   - Run the test suite to verify all tests pass
+   - Fix any failing tests
+   - Ensure good test coverage
+
+5. **Commit Tests**:
+   - Stage test files: git add .
+   - Commit with descriptive message: git commit -m "test: add automated tests for [feature]"
+
+## Important Testing Notes:
+- Write both unit tests and integration tests as appropriate
+- Test behavior, not implementation details
+- Write clear, descriptive test names
+- Keep tests isolated and independent
+- Use proper test utilities and helpers
+- Follow the existing test patterns in the repository
+- Ensure all tests are deterministic and reliable
+
+Begin by checking out the feature branch and analyzing the implemented code.`;
+};

package/dist/workflow-runner/config/phase-configs.js

@@ -5,6 +5,7 @@ import { analyzeFeatureWithMCP, checkFeatureAnalysisRequirements, } from '../../
 import { generateTechnicalDesign, checkTechnicalDesignRequirements, } from '../../phases/technical-design/analyzer.js';
 import { implementFeatureCode, checkCodeImplementationRequirements, } from '../../phases/code-implementation/analyzer.js';
 import { runFunctionalTesting, checkFunctionalTestingRequirements, } from '../../phases/functional-testing/analyzer.js';
+import { writeCodeTests, checkCodeTestingRequirements, } from '../../phases/code-testing/analyzer.js';
 import { refineCodeFromPRFeedback, checkCodeRefineRequirements, } from '../../phases/code-refine/analyzer.js';
 import { verifyAndResolveComments, checkCodeRefineVerificationRequirements, } from '../../phases/code-refine-verification/verifier.js';
 import { reviewPullRequest, checkCodeReviewRequirements, } from '../../phases/code-review/analyzer.js';
@@ -92,6 +93,12 @@ export const phaseConfigs = [
         execute: runFunctionalTesting,
         requirementsError: 'Functional testing requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
     },
+    {
+        name: 'code-testing',
+        checkRequirements: checkCodeTestingRequirements,
+        execute: writeCodeTests,
+        requirementsError: 'Code testing requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
     {
         name: 'code-refine',
         checkRequirements: checkCodeRefineRequirements,

package/dist/workflow-runner/executors/phase-executor.d.ts

@@ -4,5 +4,5 @@
 import { EdsgerConfig } from '../../types/index.js';
 import { PipelinePhaseOptions, PipelineResult, PhaseConfig } from '../../types/pipeline.js';
 export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };
+declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };

package/dist/workflow-runner/executors/phase-executor.js

@@ -243,6 +243,6 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     }
 };
 // Create phase runners using the configuration
-const [runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase,] = phaseConfigs.map(createPhaseRunner);
+const [runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase,] = phaseConfigs.map(createPhaseRunner);
 // Export individual phase runners for granular control
-export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };

package/dist/workflow-runner/pipeline-runner.js

@@ -6,7 +6,7 @@
  * Uses functional programming principles
  */
 import { updateFeatureStatusForPhase } from '../api/features/index.js';
-import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
 import { logPipelineStart, logPhaseResult, logPipelineComplete, shouldContinuePipeline, } from '../utils/pipeline-logger.js';
 import { handleTestFailuresWithRetry } from '../phases/functional-testing/test-retry-handler.js';
 import { handleCodeRefineWithRetry } from '../phases/code-refine/retry-handler.js';
@@ -362,7 +362,7 @@ const runFromCodeReview = async (options, config) => {
 };
 /**
  * Continue with code review and refine after PR creation
- * This is the post-PR workflow: code-review → code-refine → code-refine-verification
+ * This is the post-PR workflow: code-review → code-refine → code-refine-verification → code-testing
  */
 const continueWithCodeReviewAndRefine = async (options, config, results, verbose) => {
     if (verbose) {
@@ -381,4 +381,13 @@ const continueWithCodeReviewAndRefine = async (options, config, results, verbose
         results,
         verbose,
     });
+    if (!shouldContinuePipeline(results)) {
+        return;
+    }
+    // 3. Code Testing - write automated tests for the implemented code
+    if (verbose) {
+        console.log('\n📝 Starting code testing phase...');
+    }
+    const testingResult = await runCodeTestingPhase(options, config);
+    results.push(logPhaseResult(testingResult, verbose));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "type": "module",
   "main": "dist/index.js",
   "bin": {