edsger 0.4.6 → 0.4.8

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

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

package/dist/phases/bug-fixing/prompts.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/phases/code-implementation/analyzer-helpers.js

@@ -2,7 +2,7 @@ import { logInfo, logError } from '../../utils/logger.js';
 import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
 import { formatChecklistsForContext, processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
 import { verifyCodeImplementationCompliance, } from '../code-implementation-verification/index.js';
-import { createCodeImplementationImprovementPrompt } from '../../prompts/code-implementation-improvement.js';
+import { createCodeImplementationImprovementPrompt } from './prompts-improvement.js';
 /**
  * Perform a complete verification cycle:
  * 1. Verify code implementation against checklist

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

@@ -0,0 +1,5 @@
+import { ChecklistVerificationResult } from '../code-implementation-verification/index.js';
+/**
+ * Create a prompt for the implementation agent to improve code based on verification feedback
+ */
+export declare const createCodeImplementationImprovementPrompt: (verificationResult: ChecklistVerificationResult, branchName: string, baseBranch: string) => string;

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

@@ -0,0 +1,108 @@
+/**
+ * Create a prompt for the implementation agent to improve code based on verification feedback
+ */
+export const createCodeImplementationImprovementPrompt = (verificationResult, branchName, baseBranch) => {
+    // Format rejected items with specific feedback and improvement suggestions
+    const rejectedItemsSection = verificationResult.item_verifications
+        .filter((v) => v.verification_status === 'rejected')
+        .map((v, index) => {
+        return `### Rejected Requirement ${index + 1}
+**Checklist Item ID**: ${v.checklist_item_id}
+**Satisfaction Status**: ${v.is_satisfied ? '✅ Satisfied' : '❌ Not Satisfied'}
+**Verification Result**: ❌ REJECTED
+**Reason**: ${v.verification_reason}
+${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
+${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**💡 Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
+`;
+    })
+        .join('\n---\n');
+    // Format uncertain items with improvement suggestions
+    const uncertainItemsSection = verificationResult.item_verifications
+        .filter((v) => v.verification_status === 'uncertain')
+        .map((v, index) => {
+        return `### Uncertain Requirement ${index + 1}
+**Checklist Item ID**: ${v.checklist_item_id}
+**Satisfaction Status**: ${v.is_satisfied ? '✅ Satisfied' : '⚠️ Partially Satisfied'}
+**Verification Result**: ⚠️ UNCERTAIN
+**Reason**: ${v.verification_reason}
+${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
+${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**💡 Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
+`;
+    })
+        .join('\n---\n');
+    return `# Code Review Feedback - Improvements Required
+
+Your code implementation was reviewed by an independent code reviewer, and **${verificationResult.rejected_count} checklist requirements were NOT SATISFIED** and **${verificationResult.uncertain_count} requirements are PARTIALLY SATISFIED**.
+
+## Code Review Summary
+${verificationResult.summary}
+
+## Results Breakdown
+- ✅ Satisfied: ${verificationResult.confirmed_count}
+- ❌ Not Satisfied: ${verificationResult.rejected_count}
+- ⚠️ Partially Satisfied: ${verificationResult.uncertain_count}
+
+${verificationResult.overall_suggestions && verificationResult.overall_suggestions.length > 0 ? `## 💡 Overall Improvement Suggestions\n\n${verificationResult.overall_suggestions.map((s) => `- ${s}`).join('\n')}\n\n` : ''}
+
+${verificationResult.rejected_count > 0 ? `## ❌ Unsatisfied Requirements\n\n${rejectedItemsSection}` : ''}
+
+${verificationResult.uncertain_count > 0 ? `## ⚠️ Partially Satisfied Requirements\n\n${uncertainItemsSection}` : ''}
+
+---
+
+## Your Task: Improve Your Code Implementation
+
+You are currently on branch **${branchName}** (based on ${baseBranch}). You need to **improve your code** to satisfy the checklist requirements.
+
+**What You Should Do**:
+
+1. **Review the improvement suggestions** provided above for each rejected/uncertain requirement
+2. **Follow the specific, actionable suggestions** from the code reviewer
+3. **Modify your code** to address the concerns and implement the suggested improvements
+4. **Fix code quality issues**, bugs, or security concerns identified
+5. **Ensure all requirements are adequately satisfied** based on the feedback
+6. **Commit your improvements** to the same branch
+
+**IMPORTANT Guidelines**:
+- **Pay close attention to the 💡 Improvement Suggestions** - these tell you exactly what to fix
+- **Address all concerns** raised by the reviewer
+- **Test your changes** to ensure they work correctly
+- **Follow best practices** for code quality, security, and performance
+- **Commit your improvements** with a clear message explaining what was fixed
+- The code will be reviewed again after your improvements
+
+**Git Workflow**:
+1. You are already on branch ${branchName}
+2. Make the necessary code changes based on feedback
+3. Run tests to ensure everything works
+4. Commit your improvements: \`git commit -m "fix: address code review feedback - <brief description>"\`
+
+**CRITICAL - Output Format**:
+You MUST return ONLY the JSON object below after completing your improvements. Do NOT include any explanatory text, commentary, or markdown before or after the JSON. Return ONLY the JSON in this exact format:
+
+\`\`\`json
+{
+  "implementation_result": {
+    "feature_id": "...",
+    "branch_name": "${branchName}",
+    "files_modified": ["list", "of", "modified", "files"],
+    "commit_hash": "new commit hash after improvements",
+    "summary": "Brief description of improvements made based on code review feedback",
+    "tests_passed": true,
+    "pre_commit_passed": true,
+    "checklist_item_results": [
+      {
+        "checklist_item_id": "EXACT_CHECKLIST_ITEM_UUID_FROM_ID_FIELD",
+        "is_passed": true,
+        "value": "Result value based on item type",
+        "notes": "Optional notes about this checklist item"
+      }
+    ]
+  }
+}
+\`\`\`
+
+IMPORTANT: Return ONLY the JSON above. Do not add any text explaining what you did or how you improved the code. The JSON should be the complete and only content of your response.
+
+Begin improving your code implementation based on the code review feedback.`;
+};

package/dist/phases/code-implementation/prompts.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/phases/code-implementation/prompts.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/phases/code-implementation-verification/prompts.d.ts

@@ -0,0 +1,3 @@
+import { EdsgerConfig } from '../../types/index.js';
+export declare const createCodeImplementationVerificationSystemPrompt: (_config: EdsgerConfig) => string;
+export declare const createCodeImplementationVerificationPrompt: (featureId: string, branchName: string, baseBranch: string, featureName: string, featureDescription: string, checklistContext: string) => string;

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

@@ -0,0 +1,176 @@
+export const createCodeImplementationVerificationSystemPrompt = (_config) => {
+    return `You are an independent senior code reviewer and quality assurance auditor specializing in verifying code implementations against requirements.
+
+**Your Role**: Conduct thorough code review to verify that the implementation satisfies all checklist requirements.
+
+**CRITICAL - You are NOT the implementer**: You are a separate, independent reviewer auditing someone else's work. Your job is to verify compliance, not to implement or fix code.
+
+**Available Tools**:
+- Bash: Git operations to review code changes (git diff, git show, git log)
+- Read: Examine code files in detail
+- Glob: Find files in the repository
+
+**Verification Process**:
+
+1. **Switch to Feature Branch**: The specific branch name (e.g., dev/feature-id) will be provided in the user prompt
+   \`git checkout [branch-name]\`
+
+2. **Review Git Changes**: Use git diff to see what was changed compared to the base branch
+   \`git diff [base-branch]...[feature-branch]\`
+   \`git log [base-branch]..[feature-branch]\`
+
+3. **Read Modified Files**: Use Read tool to examine the actual code implementation in detail
+
+4. **Code Review**: Evaluate the code changes for:
+   - Code quality and best practices
+   - Proper error handling and validation
+   - Security considerations
+   - Performance implications
+   - Test coverage
+   - Documentation and comments
+
+5. **Checklist Verification**: For each checklist item, determine if it is satisfied by the implementation:
+   - **CONFIRMED (✅)**: The code clearly satisfies the requirement with high quality
+   - **REJECTED (❌)**: The requirement is not implemented or implementation is inadequate
+   - **UNCERTAIN (⚠️)**: Partially implemented or quality concerns exist
+
+6. **Provide Improvement Suggestions**: For rejected or uncertain items, give specific, actionable suggestions
+
+**Verification Standards**:
+
+- ✅ **CONFIRMED**: Code clearly implements the requirement with good quality
+  - Implementation is complete and functional
+  - Code follows best practices
+  - Proper error handling and validation
+  - Adequate test coverage
+  - Good documentation
+
+- ❌ **REJECTED**: Requirement is not satisfied
+  - Requirement not implemented at all
+  - Implementation is fundamentally incorrect
+  - Critical quality issues or bugs
+  - Security vulnerabilities
+  - Missing essential error handling
+
+- ⚠️ **UNCERTAIN**: Partial implementation or quality concerns
+  - Basic implementation exists but incomplete
+  - Code works but has quality issues
+  - Missing edge case handling
+  - Insufficient test coverage
+  - Poor documentation or code clarity
+
+**Important Guidelines**:
+- Base your verification on ACTUAL CODE CHANGES, not on claims or summaries
+- Review the git diff to see exactly what was changed
+- Read the modified files to understand the implementation
+- Be thorough and objective in your assessment
+- Provide specific, actionable improvement suggestions
+- Consider integration with existing code
+- Check for potential bugs, security issues, or performance problems
+
+**CRITICAL - Result Format**:
+You MUST return ONLY a JSON object with your verification results. Do NOT include any explanatory text before or after the JSON. Return ONLY the JSON in this EXACT format:
+
+\`\`\`json
+{
+  "verification_result": {
+    "overall_status": "passed" | "failed" | "partial",
+    "summary": "Brief summary of verification findings",
+    "confirmed_count": 0,
+    "rejected_count": 0,
+    "uncertain_count": 0,
+    "item_verifications": [
+      {
+        "checklist_item_id": "EXACT_CHECKLIST_ITEM_UUID",
+        "is_satisfied": true | false,
+        "verification_status": "confirmed" | "rejected" | "uncertain",
+        "verification_reason": "Detailed explanation of why this status was assigned",
+        "concerns": ["Specific concern 1", "Specific concern 2"],
+        "improvement_suggestions": ["Actionable suggestion 1", "Actionable suggestion 2"]
+      }
+    ],
+    "overall_suggestions": ["General improvement suggestion 1", "General improvement suggestion 2"]
+  }
+}
+\`\`\`
+
+IMPORTANT: Return ONLY the JSON above. Do not add any text explaining your verification process or findings. The JSON should be the complete and only content of your response.
+
+Focus on objective, thorough code review based on actual implementation artifacts.`;
+};
+export const createCodeImplementationVerificationPrompt = (featureId, branchName, baseBranch, featureName, featureDescription, checklistContext) => {
+    return `# Code Implementation Verification Task
+
+You are verifying the code implementation for feature: **${featureName}**
+
+## Feature Information
+- **Feature ID**: ${featureId}
+- **Description**: ${featureDescription}
+- **Implementation Branch**: ${branchName}
+- **Base Branch**: ${baseBranch}
+
+## Checklist Requirements to Verify
+${checklistContext}
+
+---
+
+## Your Verification Process
+
+Follow these steps systematically:
+
+### Step 1: Switch to Feature Branch
+\`\`\`bash
+git checkout ${branchName}
+\`\`\`
+
+### Step 2: Review Code Changes
+Compare the feature branch with the base branch to see what was changed:
+\`\`\`bash
+git diff ${baseBranch}...${branchName}
+\`\`\`
+
+Also review the commit history:
+\`\`\`bash
+git log ${baseBranch}..${branchName} --oneline
+\`\`\`
+
+### Step 3: Read Modified Files
+Use the Read tool to examine the actual code implementation in detail. Look at:
+- New files created
+- Modified files
+- Implementation logic
+- Error handling
+- Test coverage
+
+### Step 4: Verify Against Checklist
+For each checklist item, evaluate the implementation:
+- Is the requirement implemented?
+- Is the implementation complete and correct?
+- Does it follow best practices?
+- Are there quality concerns?
+
+### Step 5: Assign Verification Status
+For each checklist item:
+- ✅ **CONFIRMED**: Code clearly satisfies the requirement with good quality
+- ❌ **REJECTED**: Requirement not implemented or implementation inadequate
+- ⚠️ **UNCERTAIN**: Partial implementation or quality concerns
+
+### Step 6: Provide Improvement Suggestions
+For rejected or uncertain items, provide specific, actionable suggestions on how to improve the implementation.
+
+---
+
+## Important Notes
+
+- **Review ACTUAL CODE**: Base your verification on the actual code changes in git diff, not on summaries
+- **Be Thorough**: Read the modified files to understand the implementation
+- **Be Objective**: Provide fair, evidence-based assessments
+- **Be Specific**: Give concrete examples and actionable suggestions
+- **Focus on Quality**: Consider code quality, security, performance, and maintainability
+
+## Output Format
+
+Return your verification results in the required JSON format. Include all checklist items with their verification status and improvement suggestions.
+
+Begin your systematic code review now.`;
+};

package/dist/phases/code-implementation-verification/verifier.js

@@ -1,6 +1,6 @@
 import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
-import { createCodeImplementationVerificationSystemPrompt, createCodeImplementationVerificationPrompt, } from '../../prompts/code-implementation-verification.js';
+import { createCodeImplementationVerificationSystemPrompt, createCodeImplementationVerificationPrompt, } from './prompts.js';
 function userMessage(content) {
     return {
         type: 'user',

package/dist/phases/code-refine-verification/verifier.d.ts

@@ -3,11 +3,13 @@
  * Verifies that all PR review comments have been addressed and resolves them
  * Uses GitHub GraphQL API to accurately detect unresolved review threads
  */
+import { EdsgerConfig } from '../../types/index.js';
 export interface CodeRefineVerificationOptions {
     featureId: string;
     mcpServerUrl: string;
     mcpToken: string;
     githubToken: string;
+    config: EdsgerConfig;
     verbose?: boolean;
 }
 export interface CodeRefineVerificationData {
@@ -42,7 +44,7 @@ export interface CodeRefineVerificationResult {
     data: CodeRefineVerificationData;
 }
 /**
- * Verify and resolve PR review comments using GraphQL API
+ * Verify and resolve PR review comments using GraphQL API and LLM analysis
  */
 export declare function verifyAndResolveComments(options: CodeRefineVerificationOptions): Promise<CodeRefineVerificationResult>;
 export declare function checkCodeRefineVerificationRequirements(): Promise<boolean>;