edsger 0.41.2 → 0.42.0

package/dist/phases/technical-design/mcp-server.d.ts

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

package/dist/phases/technical-design/mcp-server.js

@@ -1,157 +0,0 @@
-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 technical design generation
-export const createTechnicalDesignMcpServer = () => {
-    return createSdkMcpServer({
-        name: 'edsger-technical-design-mcp',
-        version: '1.0.0',
-        tools: [
-            tool('get_feature_info', 'Get comprehensive feature and product information for technical design', {
-                feature_id: z.string().describe('Feature ID to analyze'),
-            }, async (args) => {
-                try {
-                    // Get feature details using the features/get endpoint
-                    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',
-                        };
-                    }
-                    const featureInfo = {
-                        feature,
-                        product: productInfo,
-                    };
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify(featureInfo, null, 2),
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    console.error('Error in get_feature_info:', error);
-                    throw error;
-                }
-            }),
-            tool('get_existing_user_stories', 'Get existing user stories for a feature to understand requirements', {
-                feature_id: z.string().describe('Feature ID to get user stories for'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('user_stories/list', {
-                    feature_id: args.feature_id,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }),
-            tool('get_existing_test_cases', 'Get existing test cases for a feature to understand testing requirements', {
-                feature_id: z.string().describe('Feature ID to get test cases for'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('test_cases/list', {
-                    feature_id: args.feature_id,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }),
-            tool('get_current_technical_design', 'Get the current technical design for a feature if it exists', {
-                feature_id: z
-                    .string()
-                    .describe('Feature ID to get technical design for'),
-            }, async (args) => {
-                try {
-                    const result = (await callMcpEndpoint('features/get', {
-                        feature_id: args.feature_id,
-                    }));
-                    const currentDesign = result.features?.[0]?.technical_design || null;
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    has_existing_design: !!currentDesign,
-                                    current_technical_design: currentDesign,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    console.error('Error getting current technical design:', error);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    has_existing_design: false,
-                                    current_technical_design: null,
-                                    error: 'Failed to retrieve current design',
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-            }),
-            tool('save_technical_design', 'Save the generated technical design for a feature', {
-                feature_id: z
-                    .string()
-                    .describe('Feature ID to save technical design for'),
-                technical_design: z
-                    .string()
-                    .describe('Technical design content to save'),
-            }, async (args) => {
-                try {
-                    const result = await callMcpEndpoint('features/update', {
-                        feature_id: args.feature_id,
-                        technical_design: args.technical_design,
-                    });
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    message: 'Technical design saved successfully',
-                                    result,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    console.error('Error saving technical design:', error);
-                    throw error;
-                }
-            }),
-        ],
-    });
-};

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

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

package/dist/phases/technical-design/prompts-improvement.js

@@ -1,93 +0,0 @@
-/**
- * Create a prompt for the technical design agent to improve based on verification feedback
- */
-export const createTechnicalDesignImprovementPrompt = (verificationResult, previousDesign) => {
-    // 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 `# Verification Feedback - Design Improvements Required
-
-Your previous technical design was verified, and **${verificationResult.rejected_count} checklist requirements were NOT SATISFIED** and **${verificationResult.uncertain_count} requirements are PARTIALLY SATISFIED**.
-
-## Verification 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 Previous Technical Design
-
-${previousDesign}
-
----
-
-## Your Task: Improve Your Technical Design
-
-You need to **revise and improve** your technical design document 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** - they tell you exactly what to add or modify
-3. **Expand and enhance** the technical design document as suggested by the verifier
-4. **Add missing sections, diagrams, or specifications** as indicated
-5. **Ensure each requirement is adequately covered** based on the feedback
-
-**IMPORTANT Guidelines**:
-- **Pay close attention to the 💡 Improvement Suggestions** - these are specific actions you should take
-- You can **keep the good parts** of your existing design
-- **Add NEW sections and details** exactly as suggested to satisfy the unsatisfied requirements
-- **Be specific and technical** - your design will be verified again
-- The suggestions are your roadmap - follow them to ensure verification passes
-- Ensure your design directly addresses the checklist requirements with sufficient technical depth
-
-**CRITICAL - Output Format**:
-You MUST return ONLY the JSON object below. Do NOT include any explanatory text, commentary, or markdown before or after the JSON. Return ONLY the JSON in this exact format:
-
-\`\`\`json
-{
-  "technical_design_result": {
-    "feature_id": "...",
-    "status": "success",
-    "summary": "Improved technical design based on verification feedback",
-    "technical_design": "The COMPLETE improved technical design document in markdown format",
-    "recommendations": "..."
-  }
-}
-\`\`\`
-
-IMPORTANT: Return ONLY the JSON above. Do not add any text explaining what you did or how you improved the design. The JSON should be the complete and only content of your response.`;
-};

package/dist/phases/technical-design-verification/verifier.d.ts

@@ -1,53 +0,0 @@
-/**
- * Checklist verification agent for technical design
- * This agent independently reviews checklist compliance to ensure quality
- */
-import { EdsgerConfig } from '../../types/index.js';
-import { ChecklistPhaseContext } from '../../services/checklist.js';
-import { FeedbacksContext } from '../../services/feedbacks.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 FeedbackVerificationResult {
-    feedback_id: string;
-    feedback_title: string;
-    is_addressed: boolean;
-    verification_status: 'confirmed' | 'rejected' | 'uncertain';
-    verification_reason: string;
-    concerns?: string[];
-    improvement_suggestions?: string[];
-}
-export interface ChecklistVerificationResult {
-    all_verified: boolean;
-    total_items: number;
-    confirmed_count: number;
-    rejected_count: number;
-    uncertain_count: number;
-    item_verifications: ChecklistItemVerificationResult[];
-    feedbacks_verified?: boolean;
-    total_feedbacks?: number;
-    feedbacks_confirmed_count?: number;
-    feedbacks_rejected_count?: number;
-    feedbacks_uncertain_count?: number;
-    feedback_verifications?: FeedbackVerificationResult[];
-    summary: string;
-    overall_suggestions?: string[];
-}
-export interface VerifyTechnicalDesignOptions {
-    checklistContext: ChecklistPhaseContext;
-    feedbacksContext?: FeedbacksContext | null;
-    featureId: string;
-    featureName: string;
-    featureDescription?: string;
-    technicalDesign: string;
-    verbose?: boolean;
-}
-/**
- * Verify checklist compliance for technical design using an independent AI agent
- */
-export declare function verifyTechnicalDesignCompliance(options: VerifyTechnicalDesignOptions, config: EdsgerConfig): Promise<ChecklistVerificationResult>;

package/dist/phases/technical-design-verification/verifier.js

@@ -1,170 +0,0 @@
-/**
- * Checklist verification agent for technical design
- * This agent independently reviews checklist compliance to ensure quality
- */
-import { query } from '@anthropic-ai/claude-code';
-import { logInfo, logError } from '../../utils/logger.js';
-import { createTechnicalDesignVerificationPrompt, createTechnicalDesignVerificationSystemPrompt, } from './prompts.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content: content },
-    };
-}
-async function* prompt(verificationPrompt) {
-    yield userMessage(verificationPrompt);
-}
-/**
- * Verify checklist compliance for technical design using an independent AI agent
- */
-export async function verifyTechnicalDesignCompliance(options, config) {
-    const { checklistContext, feedbacksContext, featureId, featureName, featureDescription, technicalDesign, verbose, } = options;
-    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
-    const totalFeedbacks = feedbacksContext?.feedbacks?.length || 0;
-    const hasFeedbacks = totalFeedbacks > 0;
-    if (verbose) {
-        logInfo('🔍 Starting technical design verification...');
-        logInfo(`   Verifying ${totalChecklistItems} checklist items`);
-        if (hasFeedbacks) {
-            logInfo(`   Verifying ${totalFeedbacks} human feedbacks`);
-        }
-    }
-    try {
-        const systemPrompt = createTechnicalDesignVerificationSystemPrompt(config);
-        const verificationPrompt = createTechnicalDesignVerificationPrompt({
-            checklistContext,
-            feedbacksContext: feedbacksContext || undefined,
-            featureId,
-            featureName,
-            featureDescription,
-            technicalDesign,
-        });
-        let lastAssistantResponse = '';
-        let verificationResult = null;
-        if (verbose) {
-            logInfo('🤖 Starting verification agent query...');
-        }
-        // Use Claude Code SDK for verification
-        for await (const message of query({
-            prompt: prompt(verificationPrompt),
-            options: {
-                appendSystemPrompt: systemPrompt,
-                model: config.claude.model || 'sonnet',
-                maxTurns: 100,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`   Received message type: ${message.type}`);
-            }
-            // Capture assistant responses
-            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}`);
-                        }
-                    }
-                }
-            }
-            if (message.type === 'result') {
-                if (message.subtype === 'success') {
-                    logInfo('\n✅ Verification completed, parsing results...');
-                    try {
-                        const responseText = message.result || lastAssistantResponse;
-                        // Try to extract JSON from markdown code block
-                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                        let jsonResult = null;
-                        if (jsonBlockMatch) {
-                            jsonResult = JSON.parse(jsonBlockMatch[1]);
-                        }
-                        else {
-                            jsonResult = JSON.parse(responseText);
-                        }
-                        if (jsonResult && jsonResult.verification) {
-                            verificationResult = jsonResult.verification;
-                        }
-                        else {
-                            throw new Error('Invalid verification JSON structure');
-                        }
-                    }
-                    catch (error) {
-                        logError(`Failed to parse verification result: ${error}`);
-                        // Return default "uncertain" result
-                        verificationResult = createUncertainVerificationResult(checklistContext, 'Failed to parse verification response');
-                    }
-                }
-                else {
-                    logError(`\n⚠️ Verification incomplete: ${message.subtype}`);
-                    verificationResult = createUncertainVerificationResult(checklistContext, `Verification incomplete: ${message.subtype}`);
-                }
-            }
-        }
-        if (!verificationResult) {
-            verificationResult = createUncertainVerificationResult(checklistContext, 'No verification result received');
-        }
-        if (verbose) {
-            logInfo('\n📊 Verification Summary:');
-            logInfo(`   Total checklist items: ${verificationResult.total_items}`);
-            logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
-            logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
-            logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
-            if (verificationResult.total_feedbacks &&
-                verificationResult.total_feedbacks > 0) {
-                logInfo(`\n   Total feedbacks: ${verificationResult.total_feedbacks}`);
-                logInfo(`   ✅ Confirmed: ${verificationResult.feedbacks_confirmed_count || 0}`);
-                logInfo(`   ❌ Rejected: ${verificationResult.feedbacks_rejected_count || 0}`);
-                logInfo(`   ⚠️  Uncertain: ${verificationResult.feedbacks_uncertain_count || 0}`);
-            }
-            logInfo(`\n   Summary: ${verificationResult.summary}`);
-            if (verificationResult.rejected_count > 0) {
-                logInfo('\n❌ Rejected checklist items:');
-                verificationResult.item_verifications
-                    .filter((v) => v.verification_status === 'rejected')
-                    .forEach((v) => {
-                    logInfo(`   - ${v.checklist_item_id}`);
-                    logInfo(`     Reason: ${v.verification_reason}`);
-                });
-            }
-            if (verificationResult.feedbacks_rejected_count &&
-                verificationResult.feedbacks_rejected_count > 0) {
-                logInfo('\n❌ Rejected feedbacks:');
-                verificationResult.feedback_verifications
-                    ?.filter((v) => v.verification_status === 'rejected')
-                    .forEach((v) => {
-                    logInfo(`   - ${v.feedback_title}`);
-                    logInfo(`     Reason: ${v.verification_reason}`);
-                });
-            }
-        }
-        return verificationResult;
-    }
-    catch (error) {
-        logError(`Technical design verification failed: ${error instanceof Error ? error.message : String(error)}`);
-        return createUncertainVerificationResult(checklistContext, `Verification error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Create a default "uncertain" verification result when verification fails
- */
-function createUncertainVerificationResult(checklistContext, reason) {
-    // Get all checklist items
-    const allItems = checklistContext.checklists.flatMap((checklist) => checklist.items.map((item) => ({
-        checklist_item_id: item.id,
-    })));
-    return {
-        all_verified: false,
-        total_items: allItems.length,
-        confirmed_count: 0,
-        rejected_count: 0,
-        uncertain_count: allItems.length,
-        item_verifications: allItems.map((item) => ({
-            checklist_item_id: item.checklist_item_id,
-            is_satisfied: false,
-            verification_status: 'uncertain',
-            verification_reason: reason,
-        })),
-        summary: `Verification could not be completed: ${reason}`,
-    };
-}

package/dist/services/feature-branches.d.ts

@@ -1,77 +0,0 @@
-/**
- * Feature Branches service for pipeline integration
- * Allows phases to manage feature branches via MCP
- */
-import { PipelinePhaseOptions } from '../types/pipeline.js';
-export interface FeatureBranch {
-    id: string;
-    feature_id: string;
-    name: string;
-    description: string | null;
-    branch_name: string | null;
-    base_branch_id: string | null;
-    pull_request_url: string | null;
-    pull_request_number: number | null;
-    status: 'pending' | 'in_progress' | 'ready_for_review' | 'merged' | 'closed';
-    created_at: string;
-    updated_at: string;
-}
-export interface CreateBranchInput {
-    name: string;
-    description?: string;
-    branch_name?: string;
-    base_branch_id?: string;
-    status?: FeatureBranch['status'];
-}
-/**
- * List all branches for a feature
- */
-export declare function getFeatureBranches(options: PipelinePhaseOptions): Promise<FeatureBranch[]>;
-/**
- * Get the current active branch for a feature
- */
-export declare function getCurrentBranch(options: PipelinePhaseOptions): Promise<FeatureBranch | null>;
-/**
- * Create feature branches
- */
-export declare function createFeatureBranches(options: PipelinePhaseOptions, branches: CreateBranchInput[]): Promise<FeatureBranch[]>;
-/**
- * Update a feature branch
- */
-export declare function updateFeatureBranch(branchId: string, updates: Partial<Omit<FeatureBranch, 'id' | 'feature_id' | 'created_at' | 'updated_at'>>, verbose?: boolean): Promise<FeatureBranch>;
-/**
- * Clear all branches for a feature (used before re-planning)
- */
-export declare function clearFeatureBranches(options: PipelinePhaseOptions, force?: boolean): Promise<number>;
-/**
- * Format feature branches for context (to include in prompts)
- */
-export declare function formatBranchesForContext(branches: FeatureBranch[]): string;
-/**
- * Check if feature has multiple branches planned
- */
-export declare function hasMultipleBranches(options: PipelinePhaseOptions): Promise<boolean>;
-/**
- * Get next pending branch to work on
- */
-export declare function getNextPendingBranch(options: PipelinePhaseOptions): Promise<FeatureBranch | null>;
-/**
- * Check if all branches are completed
- */
-export declare function allBranchesCompleted(options: PipelinePhaseOptions): Promise<boolean>;
-/**
- * Get the base branch information for a feature branch.
- * Returns:
- * - If base_branch_id is set and that branch is merged: use main
- * - If base_branch_id is set and that branch is not merged: use that branch's branch_name
- * - If base_branch_id is null: use main
- */
-export declare function getBaseBranchInfo(branch: FeatureBranch, allBranches: FeatureBranch[], mainBranch?: string): Promise<{
-    baseBranch: string;
-    needsRebase: boolean;
-    baseBranchMerged: boolean;
-}>;
-/**
- * Get branch by ID
- */
-export declare function getBranchById(branchId: string, verbose?: boolean): Promise<FeatureBranch | null>;