edsger 0.1.5 → 0.2.0

package/README.md

@@ -1,144 +1,182 @@
-# Edsger - AI-Powered Code Review CLI
+# Edsger
 
-An AI-powered code review tool that uses Claude Code to review your uncommitted changes. Perfect for pre-commit hooks and automated code quality checks.
+AI-powered software development CLI tool with comprehensive feature management, code review, and testing capabilities using Claude Code SDK and MCP integration.
 
 ## Features
 
-- 🤖 **AI-Powered Reviews**: Uses Claude Code for intelligent code analysis
-- 🔗 **Git Integration**: Reviews uncommitted or staged changes automatically  
-- ⚙️ **Configurable**: Customize patterns, exclusions, and review severity
-- 🚀 **Hook-Friendly**: Designed for husky pre-commit hooks and CI/CD
-- 📊 **Detailed Output**: Clear feedback with blocking/warning/passing results
+### 🔍 Code Review
 
-## Installation
+- **AI-Powered Reviews**: Uses Claude Code SDK for intelligent code analysis
+- **Git Integration**: Reviews uncommitted or staged changes automatically
+- **Configurable**: Customize patterns, exclusions, and review severity
+- **Hook-Friendly**: Designed for pre-commit hooks and CI/CD automation
+- **Detailed Output**: Clear feedback with blocking/warning/passing results
 
-First, install Claude Code CLI globally:
+### 🎯 Feature Analysis
 
-```bash
-npm install -g @anthropic-ai/claude-code
-```
+- **MCP Integration**: Analyze features using Model Context Protocol
+- **User Story Generation**: Create comprehensive user stories for features
+- **Test Case Creation**: Generate detailed test cases with criticality levels
+- **Deduplication**: Avoid creating similar existing user stories and test cases
+- **Real-time Streaming**: Live analysis feedback with Claude Code SDK
+
+### 🎨 Technical Design
+
+- **Design Generation**: Create technical specifications for features
+- **Architecture Planning**: Generate implementation roadmaps and technical details
+- **Integration Support**: Works with MCP for structured design output
+
+### 💻 Code Implementation
+
+- **Feature Implementation**: Automatically implement features based on specifications
+- **Branch Management**: Creates feature branches and manages git workflow
+- **Code Generation**: AI-powered code writing with proper git integration
+
+### 🎭 Functional Testing
+
+- **Automated Testing**: Run Playwright-based functional tests for features
+- **Test Execution**: Execute test cases with detailed reporting
+- **Status Tracking**: Monitor test results with pass/fail statistics
 
-Then install Edsger:
+### 🚀 Workflow Management
+
+- **Continuous Processing**: Monitor and process features ready for development
+- **End-to-End Automation**: Complete feature lifecycle from analysis to testing
+- **Real-time Monitoring**: Live workflow processing with statistics and graceful shutdown
+
+## Installation
 
 ```bash
-npm install -g edsger
+npm install edsger
 ```
 
-## Quick Start
+## Usage
+
+### Code Review
 
 ```bash
 # Review all uncommitted changes
 edsger --review
 
-# Review only staged changes  
+# Review only staged changes
 edsger --review --staged
 
-# Review specific files
-edsger --review --files "src/**/*.js"
+# Review specific file patterns
+edsger --review --files "**/*.ts" "**/*.js"
 
 # Verbose output
 edsger --review --verbose
 ```
 
-## Configuration
+### Feature Analysis
 
-Create `.edsgerrc` in your project root or add an `edsger` section to `package.json`:
+```bash
+# Analyze a feature and generate user stories/test cases
+edsger --feature-analysis <feature-id>
 
-```json
-{
-  "patterns": ["src/**/*.js", "src/**/*.ts"],
-  "exclude": ["**/*.test.js", "**/*.spec.js"],
-  "severity": "error",
-  "maxFiles": 50,
-  "claude": {
-    "model": "sonnet",
-    "timeout": 120000
-  }
-}
+# Verbose analysis output
+edsger --feature-analysis <feature-id> --verbose
 ```
 
-### Configuration Options
+### Technical Design
 
-- **patterns**: File patterns to include (default: common code files)
-- **exclude**: File patterns to exclude (default: tests, builds, node_modules)  
-- **severity**: `"error"` (exit 1 on issues) or `"warning"` (exit 0 always)
-- **maxFiles**: Maximum files to review in one run
-- **claude.model**: Claude model to use (`sonnet`, `opus`, etc.)
-- **claude.timeout**: Timeout in milliseconds
-
-## Integration with Husky
-
-Add to your `package.json`:
+```bash
+# Generate technical design for a feature
+edsger --technical-design <feature-id>
 
-```json
-{
-  "scripts": {
-    "review": "edsger --review"
-  }
-}
+# Verbose design output
+edsger --technical-design <feature-id> --verbose
 ```
 
-Setup husky hook:
+### Code Implementation
 
 ```bash
-npx husky add .husky/pre-commit "npm run review"
+# Implement feature code based on specifications
+edsger --implement <feature-id>
+
+# Verbose implementation output
+edsger --implement <feature-id> --verbose
 ```
 
-## Exit Codes
+### Functional Testing
 
-- **0**: Review passed or warnings only
-- **1**: Review failed with blocking issues
-- **1**: Configuration or runtime errors
+```bash
+# Run functional tests for a feature
+edsger --test <feature-id>
 
-## Examples
+# Verbose test output
+edsger --test <feature-id> --verbose
+```
+
+### Workflow Management
 
-### Basic Usage
 ```bash
-edsger --review
-```
+# Run continuous workflow processor
+edsger --workflow
 
-### Review Only Staged Files
-```bash  
-edsger --review --staged
+# Run with verbose logging
+edsger --workflow --verbose
 ```
 
-### Review Specific Patterns
+### Default Behavior
+
 ```bash
-edsger --review --files "src/**/*.js" "lib/**/*.ts"
+# Auto-detects mode based on environment:
+# - If EDSGER_PRODUCT_ID and EDSGER_MCP_TOKEN are set: workflow mode
+# - Otherwise: code review mode
+edsger
 ```
 
-### Custom Configuration
-```bash
-edsger --review --config ./my-config.json --verbose
+## Configuration
+
+Create a configuration file (`.edsgerrc.json`, `edsger.config.js`, etc.):
+
+```json
+{
+  "patterns": ["**/*.js", "**/*.ts"],
+  "exclude": ["node_modules/**", "*.test.js"],
+  "severity": "error",
+  "maxFiles": 100,
+  "claude": {
+    "model": "sonnet",
+    "timeout": 120000
+  }
+}
 ```
 
-## Requirements
+## Environment Variables
 
-- Claude Code CLI installed and authenticated
-- Active Claude subscription or API access
+### Required for Advanced Features (Feature Analysis, Technical Design, Implementation, Testing, Workflow)
 
-## How It Works
+- `EDSGER_MCP_SERVER_URL`: MCP server URL for feature operations
+- `EDSGER_MCP_TOKEN`: Required authentication token for MCP server
+- `EDSGER_PRODUCT_ID`: Product ID for workflow management (optional for workflow mode)
 
-1. **Git Analysis**: Detects uncommitted or staged file changes
-2. **File Filtering**: Applies include/exclude patterns from configuration  
-3. **AI Review**: Sends files to Claude Code for intelligent analysis
-4. **Result Processing**: Categorizes feedback as OK/WARN/BLOCK
-5. **Exit Handling**: Returns appropriate exit codes for automation
+### Configuration Options
 
-## Troubleshooting
+- **patterns**: File patterns to include (default: common code files)
+- **exclude**: File patterns to exclude (default: tests, builds, node_modules)
+- **severity**: `"error"` (exit 1 on issues) or `"warning"` (exit 0 always)
+- **maxFiles**: Maximum files to review in one run
+- **claude.model**: Claude model to use (`sonnet`, `opus`, etc.)
+- **claude.timeout**: Timeout in milliseconds
+
+## Git Hooks Integration
 
-**"Claude Code CLI not found"**
-- Install: `npm install -g @anthropic-ai/claude-code`
-- Verify: `claude --version`
+Add to your `.git/hooks/pre-commit`:
 
-**"Not in a git repository"**
-- Run from within a git repository
-- Initialize with `git init` if needed
+```bash
+#!/bin/sh
+npx edsger --review --staged
+```
+
+## Requirements
 
-**"No files to review"**  
-- Check if you have uncommitted changes: `git status`
-- Verify your file patterns include the changed files
+- Node.js >= 18.0.0
+- `@anthropic-ai/claude-code` SDK
+- MCP server for advanced feature operations (analysis, design, implementation, testing)
+- Playwright for functional testing (when using `--test` flag)
 
 ## License
 
-ISC
+ISC

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

@@ -0,0 +1,19 @@
+import { EdsgerConfig } from '../types.js';
+export interface BugFixingOptions {
+    featureId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+    testErrors: string;
+    attemptNumber?: number;
+    verbose?: boolean;
+}
+export interface BugFixingResult {
+    featureId: string;
+    fixSummary: string | null;
+    status: 'success' | 'error';
+    message: string;
+    filesFixed?: string[];
+    attemptNumber?: number;
+}
+export declare const fixTestFailures: (options: BugFixingOptions, config: EdsgerConfig) => Promise<BugFixingResult>;
+export declare function checkBugFixingRequirements(): Promise<boolean>;

package/dist/bug-fixing/analyzer.js

@@ -0,0 +1,280 @@
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../logger.js';
+import { fetchBugFixingContext, formatContextForPrompt, } from './context-fetcher.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(bugFixPrompt) {
+    yield userMessage(bugFixPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+export const fixTestFailures = async (options, config) => {
+    const { featureId, mcpServerUrl, mcpToken, testErrors, attemptNumber = 1, verbose, } = options;
+    if (verbose) {
+        logInfo(`Starting bug fixing for feature ID: ${featureId} (Attempt ${attemptNumber})`);
+        logInfo(`Using MCP server: ${mcpServerUrl}`);
+    }
+    try {
+        // Fetch all required context information via MCP endpoints
+        if (verbose) {
+            logInfo('Fetching bug fixing context via MCP endpoints...');
+        }
+        const context = await fetchBugFixingContext(mcpServerUrl, mcpToken, featureId, verbose);
+        const systemPrompt = createSystemPrompt(config);
+        const bugFixPrompt = createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context);
+        let lastAssistantResponse = '';
+        let structuredFixResult = null;
+        if (verbose) {
+            logInfo('Starting Claude Code query with pre-fetched information...');
+        }
+        // Use Claude Code SDK without MCP servers - all info is pre-fetched
+        for await (const message of query({
+            prompt: prompt(bugFixPrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 2000,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`Received message type: ${message.type}`);
+            }
+            // Stream the bug fixing 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...'}`);
+                        }
+                    }
+                }
+            }
+            else if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('\n🛠️ Bug fixing completed, parsing results...');
+                    try {
+                        // Try to extract JSON from markdown code block or parse directly
+                        const responseText = message.result || lastAssistantResponse;
+                        let jsonResult = null;
+                        // First 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 {
+                            // Try to parse the entire response as JSON
+                            jsonResult = JSON.parse(responseText);
+                        }
+                        if (jsonResult && jsonResult.fix_result) {
+                            structuredFixResult = jsonResult.fix_result;
+                        }
+                        else {
+                            throw new Error('Invalid JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse structured fix result: ${error}`);
+                        // Fallback parsing
+                        structuredFixResult = parseBugFixResponse(message.result || lastAssistantResponse);
+                    }
+                }
+                else {
+                    logError(`\n⚠️  Bug fixing incomplete: ${message.subtype}`);
+                    if (message.subtype === 'error_max_turns') {
+                        logError('💡 Try simplifying the fixes or reducing scope');
+                    }
+                    // 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.fix_result) {
+                                    structuredFixResult = jsonResult.fix_result;
+                                }
+                            }
+                            else {
+                                structuredFixResult = parseBugFixResponse(lastAssistantResponse);
+                            }
+                        }
+                        catch (error) {
+                            logError(`Failed to parse assistant response: ${error}`);
+                        }
+                    }
+                }
+            }
+        }
+        if (structuredFixResult) {
+            const { summary, files_modified } = structuredFixResult;
+            if (verbose) {
+                logInfo(`Bug fixing completed for feature: ${featureId}`);
+                if (files_modified?.length > 0) {
+                    logInfo(`Files fixed: ${files_modified.join(', ')}`);
+                }
+            }
+            return {
+                featureId,
+                fixSummary: summary || 'Bug fixes applied',
+                status: 'success',
+                message: 'Bug fixes applied successfully',
+                filesFixed: files_modified || [],
+                attemptNumber,
+            };
+        }
+        else {
+            return {
+                featureId,
+                fixSummary: null,
+                status: 'error',
+                message: 'Bug fixing failed or incomplete',
+                attemptNumber,
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Bug fixing failed: ${errorMessage}`);
+        return {
+            featureId,
+            fixSummary: null,
+            status: 'error',
+            message: `Bug fixing failed: ${errorMessage}`,
+            attemptNumber,
+        };
+    }
+};
+function createSystemPrompt(_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"
+      }
+    ]
+  }
+}
+\`\`\`
+
+Focus on systematic bug fixing based on the provided context and test failure information.`;
+}
+function createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context) {
+    const contextInfo = formatContextForPrompt(context, testErrors);
+    return `Fix the test failures for feature: ${featureId} (Attempt ${attemptNumber})
+
+${contextInfo}
+
+## Bug Fixing Instructions
+
+Follow this systematic approach:
+
+1. **Analyze Test Failures**: Study the test error messages above to understand:
+   - What specific functionality is failing
+   - Error messages and stack traces
+   - Which user stories or test cases are not working
+
+2. **Examine Current Code**: Use Read and Glob tools to understand:
+   - Current implementation that's causing failures
+   - Code structure and patterns
+   - Related files and dependencies
+
+3. **Fix Issues**: Make targeted fixes to resolve the test failures:
+   - Focus on the specific issues causing test failures
+   - Maintain existing code patterns and conventions
+   - Make minimal necessary changes
+   - Don't refactor unrelated code
+
+4. **Test Your Fixes**: Verify that your changes work:
+   - Run the tests to ensure they now pass
+   - Check that you haven't broken other functionality
+   - Ensure critical test cases still work
+
+5. **Document Changes**: Clearly explain what was fixed and why
+
+## Important Notes
+- This is attempt ${attemptNumber}, so be thorough and systematic
+- Focus ONLY on making the failing tests pass
+- Use the user stories and test cases to understand expected behavior
+- Reference the technical design and test report for additional context
+- Make sure critical functionality continues to work
+
+Begin by analyzing the test failures and examining the relevant code files.`;
+}
+function parseBugFixResponse(response) {
+    // Extract summary and file information from the response as fallback
+    const summaryMatch = response.match(/## Fix Summary\n([\s\S]*?)(?=\n##|\n\n|$)/);
+    const summary = summaryMatch ? summaryMatch[1].trim() : 'Bug fixes applied';
+    const filesMatch = response.match(/## Files Fixed\n([\s\S]*?)(?=\n##|\n\n|$)/);
+    let files_modified = [];
+    if (filesMatch) {
+        files_modified = filesMatch[1]
+            .split('\n')
+            .filter((line) => line.trim().startsWith('-'))
+            .map((line) => line.replace(/^-\s*/, '').trim());
+    }
+    return {
+        summary,
+        files_modified,
+        tests_passed: true,
+        fixes_applied: [],
+    };
+}
+export function checkBugFixingRequirements() {
+    try {
+        require.resolve('@anthropic-ai/claude-code');
+        return Promise.resolve(true);
+    }
+    catch {
+        return Promise.resolve(false);
+    }
+}

package/dist/bug-fixing/context-fetcher.d.ts

@@ -0,0 +1,40 @@
+export interface BugFixingContext {
+    feature: {
+        id: string;
+        name: string;
+        description?: string;
+        technical_design?: string;
+        status: string;
+        product_id: string;
+    };
+    user_stories: Array<{
+        id: string;
+        title: string;
+        description: string;
+        status: string;
+        [key: string]: any;
+    }>;
+    test_cases: Array<{
+        id: string;
+        name: string;
+        description: string;
+        is_critical: boolean;
+        [key: string]: any;
+    }>;
+    latest_test_report?: {
+        id: string;
+        title: string;
+        test_results: string;
+        status: string;
+        created_at: string;
+        [key: string]: any;
+    } | null;
+}
+/**
+ * Fetch all bug fixing context information via MCP endpoints
+ */
+export declare function fetchBugFixingContext(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<BugFixingContext>;
+/**
+ * Format the context into a readable string for Claude Code
+ */
+export declare function formatContextForPrompt(context: BugFixingContext, testErrors: string): string;