edsger 0.30.0 → 0.30.2

package/dist/phases/code-implementation/branch-pr-creator.js

@@ -3,8 +3,8 @@
  * Creates pull requests from dev/ branches to feat/ branches
  */
 import { Octokit } from '@octokit/rest';
-import { execSync } from 'child_process';
 import { logInfo, logError } from '../../utils/logger.js';
+import { gitPush } from '../../utils/git-push.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
 const PR_TITLE_PREFIX = 'feat: ';
@@ -40,62 +40,6 @@ export function devBranchToFeatBranch(devBranchName) {
     // If already feat/ or other format, return as-is
     return devBranchName;
 }
-/**
- * Push a branch to remote
- * Falls back to force-with-lease if normal push fails (e.g., after rebase)
- */
-async function pushBranch(branchName, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`📤 Pushing branch ${branchName} to remote...`);
-        }
-        // Try to push with -u flag (sets upstream if not already set)
-        try {
-            execSync(`git push -u origin ${branchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-            return { success: true };
-        }
-        catch (error) {
-            // If push fails, try without -u flag
-            try {
-                execSync(`git push origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                return { success: true };
-            }
-            catch (retryError) {
-                // If push still fails (likely non-fast-forward after rebase),
-                // use force-with-lease for safer force push
-                if (verbose) {
-                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-                }
-                try {
-                    execSync(`git push --force-with-lease origin ${branchName}`, {
-                        encoding: 'utf-8',
-                        stdio: verbose ? 'inherit' : 'pipe',
-                    });
-                    if (verbose) {
-                        logInfo(`✅ Successfully force pushed ${branchName}`);
-                    }
-                    return { success: true };
-                }
-                catch (forceError) {
-                    const errorMessage = forceError instanceof Error
-                        ? forceError.message
-                        : String(forceError);
-                    return { success: false, error: errorMessage };
-                }
-            }
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return { success: false, error: errorMessage };
-    }
-}
 /**
  * Create a pull request from a dev/ branch to its corresponding feat/ branch
  * This is used after code implementation in multi-branch features
@@ -115,7 +59,7 @@ export async function createBranchPullRequest(config, devBranchName, featureName
         if (verbose) {
             logInfo(`📤 Pushing ${devBranchName} to remote...`);
         }
-        const pushResult = await pushBranch(devBranchName, verbose);
+        const pushResult = gitPush({ branchName: devBranchName, token: githubToken, verbose });
         if (!pushResult.success) {
             return {
                 success: false,

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

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

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

@@ -0,0 +1,86 @@
+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 implementation context information via MCP endpoints
+ */
+export async function fetchCodeImplementationContext(featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching complete code implementation context for feature: ${featureId}`);
+        }
+        // Fetch all required data in parallel for better performance
+        const [feature, user_stories, test_cases] = await Promise.all([
+            getFeature(featureId, verbose),
+            getUserStories(featureId, verbose),
+            getTestCases(featureId, verbose),
+        ]);
+        const product = await getProduct(feature.product_id, verbose);
+        if (verbose) {
+            logInfo(`✅ Code implementation context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   User Stories: ${user_stories.length}`);
+            logInfo(`   Test Cases: ${test_cases.length}`);
+            logInfo(`   Technical Design: ${feature.technical_design ? 'Available' : 'Not available'}`);
+        }
+        return {
+            feature,
+            product,
+            user_stories,
+            test_cases,
+            technical_design: feature.technical_design,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch code implementation 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 Implementation 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 to Implement (${context.user_stories.length})
+${formatUserStories(context.user_stories)}
+
+## Test Cases to Satisfy (${context.test_cases.length})
+${formatTestCases(context.test_cases)}
+
+## Technical Design
+${context.technical_design || 'No technical design available - implement based on user stories and test cases'}
+
+---
+
+**Implementation Instructions**: Based on the above requirements, user stories, test cases, and technical design, implement the complete feature functionality. Ensure all user stories are implemented and all test cases can pass.`;
+}

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

@@ -1,6 +1,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logInfo, logError } from '../../utils/logger.js';
+import { gitPush } from '../../utils/git-push.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { fetchCodeImplementationContext, formatContextForPrompt, } from './context.js';
@@ -164,6 +165,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     // Sync feat branch to main before rebase to ensure it's up to date
     // This prevents the PR (dev → feat) from showing extra commits
     let featSyncedToMain = false;
+    let githubTokenForPush;
     if (devBranchName.startsWith('dev/')) {
         try {
             const githubConfig = await getGitHubConfig(featureId, verbose);
@@ -171,6 +173,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                 githubConfig.token &&
                 githubConfig.owner &&
                 githubConfig.repo) {
+                githubTokenForPush = githubConfig.token;
                 const { devBranchToFeatBranch } = await import('./branch-pr-creator.js');
                 const featBranchName = devBranchToFeatBranch(devBranchName);
                 if (verbose) {
@@ -200,6 +203,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         },
         forcePushAfterRebase: featSyncedToMain, // Trigger GitHub to recalculate PR diff
         baseBranchCompleted, // Tell conflict resolver to use --theirs for all conflicts
+        githubToken: githubTokenForPush,
     });
     try {
         // Fetch all required context information via MCP endpoints
@@ -462,7 +466,11 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             if (verbose) {
                 logInfo(`📤 Pushing code to remote repository...`);
             }
-            const pushResult = await pushToRemote(structuredImplementationResult.branch_name || branchName, verbose);
+            const pushResult = gitPush({
+                branchName: structuredImplementationResult.branch_name || branchName,
+                token: githubTokenForPush,
+                verbose,
+            });
             if (!pushResult.success && verbose) {
                 logError(`⚠️  Failed to push to remote: ${pushResult.error}`);
                 logInfo('   Code is committed locally and will be reviewed. Manual push may be needed.');
@@ -854,69 +862,3 @@ const parseImplementationResponse = (response, featureId) => {
         };
     }
 };
-/**
- * Push branch to remote repository
- * Falls back to force-with-lease if normal push fails (e.g., after rebase)
- */
-async function pushToRemote(branchName, verbose) {
-    try {
-        // Import exec from child_process
-        const { execSync } = await import('child_process');
-        if (verbose) {
-            logInfo(`Pushing branch ${branchName} to remote...`);
-        }
-        // Try to push with -u flag (sets upstream if not already set)
-        try {
-            execSync(`git push -u origin ${branchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-            return { success: true };
-        }
-        catch (error) {
-            // If push fails, it might be because branch already has upstream
-            // Try without -u flag
-            try {
-                execSync(`git push origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                return { success: true };
-            }
-            catch (retryError) {
-                // If push still fails (likely non-fast-forward after rebase),
-                // use force-with-lease for safer force push
-                // force-with-lease ensures we don't overwrite others' work by checking remote state
-                if (verbose) {
-                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-                }
-                try {
-                    execSync(`git push --force-with-lease origin ${branchName}`, {
-                        encoding: 'utf-8',
-                        stdio: verbose ? 'inherit' : 'pipe',
-                    });
-                    if (verbose) {
-                        logInfo(`✅ Successfully force pushed ${branchName}`);
-                    }
-                    return { success: true };
-                }
-                catch (forceError) {
-                    const errorMessage = forceError instanceof Error
-                        ? forceError.message
-                        : String(forceError);
-                    return {
-                        success: false,
-                        error: errorMessage,
-                    };
-                }
-            }
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            success: false,
-            error: errorMessage,
-        };
-    }
-}

package/dist/phases/code-implementation/mcp-server.d.ts

@@ -0,0 +1 @@
+export declare const createCodeImplementationMcpServer: () => import("@anthropic-ai/claude-code").McpSdkServerConfigWithInstance;

package/dist/phases/code-implementation/mcp-server.js

@@ -0,0 +1,93 @@
+import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code';
+import { z } from 'zod';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+// Create an SDK MCP server with custom tools for code implementation
+export const createCodeImplementationMcpServer = () => {
+    return createSdkMcpServer({
+        name: 'edsger-code-implementation-mcp',
+        version: '1.0.0',
+        tools: [
+            tool('get_complete_feature_info', 'Get comprehensive feature information including product, user stories, test cases, and technical design', {
+                feature_id: z
+                    .string()
+                    .describe('Feature ID to get complete information for'),
+            }, async (args) => {
+                try {
+                    // Get feature details
+                    const featureResult = (await callMcpEndpoint('features/get', {
+                        feature_id: args.feature_id,
+                    }));
+                    if (!featureResult.features ||
+                        featureResult.features.length === 0) {
+                        throw new Error('Feature not found');
+                    }
+                    const feature = featureResult.features[0];
+                    // Get product details
+                    const productResult = (await callMcpEndpoint('resources/read', {
+                        uri: `product://${feature.product_id}`,
+                    }));
+                    const productText = productResult.contents?.[0]?.text || '{}';
+                    let productInfo;
+                    try {
+                        productInfo = JSON.parse(productText);
+                    }
+                    catch {
+                        productInfo = {
+                            id: feature.product_id,
+                            name: 'Unknown Product',
+                        };
+                    }
+                    // Get user stories
+                    const userStoriesResult = (await callMcpEndpoint('user_stories/list', { feature_id: args.feature_id }));
+                    // Get test cases
+                    const testCasesResult = (await callMcpEndpoint('test_cases/list', {
+                        feature_id: args.feature_id,
+                    }));
+                    const completeInfo = {
+                        feature,
+                        product: productInfo,
+                        user_stories: userStoriesResult.user_stories || [],
+                        test_cases: testCasesResult.test_cases || [],
+                        technical_design: feature.technical_design || null,
+                    };
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(completeInfo, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    console.error('Error in get_complete_feature_info:', error);
+                    throw error;
+                }
+            }),
+            tool('verify_implementation_complete', 'Verify that the code implementation is complete and all tests pass', {
+                feature_id: z
+                    .string()
+                    .describe('Feature ID to verify implementation'),
+                implementation_summary: z
+                    .string()
+                    .describe('Summary of what was implemented'),
+            }, async (args) => {
+                // This tool is a placeholder for verification
+                // In reality, it would check test results, lint results, etc.
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                verified: true,
+                                feature_id: args.feature_id,
+                                summary: args.implementation_summary,
+                                message: 'Implementation verification complete',
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }),
+        ],
+    });
+};

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-verification/verifier.d.ts

@@ -0,0 +1,31 @@
+import { EdsgerConfig } from '../../types/index.js';
+export interface ChecklistItemVerificationResult {
+    checklist_item_id: string;
+    is_satisfied: boolean;
+    verification_status: 'confirmed' | 'rejected' | 'uncertain';
+    verification_reason: string;
+    concerns?: string[];
+    improvement_suggestions?: string[];
+}
+export interface ChecklistVerificationResult {
+    overall_status: 'passed' | 'failed' | 'partial';
+    summary: string;
+    confirmed_count: number;
+    rejected_count: number;
+    uncertain_count: number;
+    item_verifications: ChecklistItemVerificationResult[];
+    overall_suggestions?: string[];
+}
+export interface VerifyCodeImplementationOptions {
+    featureId: string;
+    branchName: string;
+    baseBranch: string;
+    featureName: string;
+    featureDescription?: string;
+    checklistContext: string;
+    verbose?: boolean;
+}
+/**
+ * Verify code implementation against checklist requirements by reviewing git diff
+ */
+export declare function verifyCodeImplementationCompliance(options: VerifyCodeImplementationOptions, config: EdsgerConfig): Promise<ChecklistVerificationResult>;