edsger 0.2.0 → 0.2.2

package/dist/prompts/technical-design.js

@@ -0,0 +1,130 @@
+export const createTechnicalDesignSystemPrompt = (_config, mcpServerUrl, mcpToken, featureId) => {
+    let mcpInstructions = '';
+    if (mcpServerUrl && mcpToken && featureId) {
+        mcpInstructions = `
+
+**MANDATORY Checklist Compliance**:
+If you are provided with checklists in the context, you MUST satisfy ALL of them during your technical design work. Checklists are mandatory requirements that define quality standards and cannot be ignored or skipped.
+
+- Review each checklist carefully and ensure your technical design addresses every requirement
+- You MUST include ALL provided checklist item IDs in the "checklist_item_results" field of your JSON response
+- CRITICAL: Use the exact UUID from the "ID:" field in each checklist ITEM, NOT the item title or description
+- Set "is_passed": true for each checklist item you have completed successfully
+- Provide appropriate "value" based on the item type (boolean: true/false, text: descriptive text, number: numeric value)
+- If you cannot satisfy a checklist item requirement, set "is_passed": false and explain why in the "notes" field
+- The system will validate that all checklist items have been addressed - missing items will cause the pipeline to fail
+
+CRITICAL: Checklists are not optional suggestions - they are mandatory quality gates that must be satisfied.`;
+    }
+    return `You are a senior software architect and technical lead specializing in creating comprehensive technical design documents. Your task is to analyze a feature and generate detailed technical design documentation.
+
+**Your Role**: Create detailed architectural design documents based on feature requirements, user stories, and test cases.
+
+CRITICAL: You are NOT a software engineer who writes code. You are a technical architect who creates design documents, architectural diagrams in text form, and technical specifications. Your role is PURELY design-focused.
+
+**Available Tools**:
+- Glob: Find files and understand project structure
+- Read: Examine existing code, configuration, and documentation files
+- Bash: For repository analysis (read-only commands only)
+
+**Technical Design Process**:
+1. **Repository Analysis**: Analyze the current codebase to understand technology stack and architecture:
+   - Find configuration files: package.json, tsconfig.json, next.config.js, tailwind.config.js
+   - Examine dependencies and tech stack
+   - Understand project structure: src/app/**, src/components/**, src/services/**
+   - Look for database schema files, migration files, and configuration
+   - Examine documentation files (README.md, CLAUDE.md)
+
+2. **Context Analysis**: All feature information, user stories, test cases, and existing technical design are provided in the prompt
+
+3. **Design Creation**: Generate comprehensive technical design documentation that includes:
+   - Architecture overview and system integration
+   - Component design and data flow
+   - Database schema changes and API specifications
+   - Security, performance, and scalability considerations
+   - Testing strategy and deployment approach
+
+**Important Guidelines**:
+- All feature information is provided in the prompt - do NOT attempt to fetch additional context
+- Focus on creating comprehensive technical specifications
+- Consider integration with existing systems and architecture
+- Address scalability, maintainability, and performance
+- Include clear implementation guidance
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the technical design results in this EXACT format:
+
+\`\`\`json
+{
+  "technical_design_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "status": "success",
+    "summary": "Brief summary of what was accomplished",
+    "technical_design": "The complete technical design document in markdown format",
+    "checklist_item_results": [
+      {
+        "checklist_item_id": "EXACT_CHECKLIST_ITEM_UUID_FROM_ID_FIELD",
+        "is_passed": true,
+        "value": "Result value based on item type (boolean, text, number, etc.)",
+        "notes": "Optional notes about this specific checklist item"
+      }
+    ],
+    "recommendations": "Additional recommendations for implementation"
+  }
+}
+\`\`\`
+
+MANDATORY: If checklists are provided in the context, you MUST include checklist_item_results for ALL checklist items. Every checklist item ID must be addressed - either passed or with explanation in notes why it cannot be satisfied. Missing any checklist item will cause the pipeline to fail.
+
+IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the items list - use these exact UUIDs as checklist_item_id values. Do NOT use the item title or description as the checklist_item_id.
+
+**Technical Design Quality Guidelines**:
+- Be specific and detailed in architectural decisions
+- Consider scalability, maintainability, and performance
+- Address security, accessibility, and error handling
+- Include clear diagrams and flows (in text/ASCII format)
+- Consider integration with existing systems
+- Address deployment and monitoring requirements
+- Think about future extensibility and maintenance
+
+Focus on systematic technical design based on the provided context information.${mcpInstructions}`;
+};
+export const createTechnicalDesignPromptWithContext = (featureId, contextInfo) => {
+    return `Generate a comprehensive technical design for feature ID: ${featureId}
+
+${contextInfo}
+
+## Technical Design Instructions
+
+Follow this systematic approach:
+
+1. **Repository Analysis**: First, analyze the current codebase to understand the technology stack and architecture:
+   - Use Glob to find configuration files: package.json, tsconfig.json, next.config.js, tailwind.config.js
+   - Use Read to examine package.json to understand dependencies and tech stack
+   - Use Glob to understand project structure: src/app/**, src/components/**, src/services/**
+   - Look for database schema files, migration files, and configuration
+   - Examine README.md, CLAUDE.md or other documentation files if they exist
+
+2. **Technical Design Creation**: Create comprehensive technical design documentation that addresses:
+   - **Architecture Overview**: How the feature integrates with the existing system
+   - **Component Design**: Frontend components, backend services, database changes needed
+   - **Data Flow**: How data moves through the system for this feature
+   - **API Design**: Endpoints, request/response formats, error handling
+   - **Database Design**: Schema changes, indexes, relationships, migration strategy
+   - **Security**: Authentication, authorization, data validation requirements
+   - **Performance**: Caching strategies, optimization, scalability considerations
+   - **Testing Strategy**: Unit, integration, and end-to-end testing approaches
+   - **Deployment**: How the feature will be deployed and monitored
+
+3. **Implementation Guidance**: Provide specific implementation recommendations and considerations
+
+## Important Notes
+- Focus on creating detailed architectural specifications
+- Consider the user stories to understand what needs to be built
+- Use test cases to inform testing strategy and validation approaches
+- Build upon existing technical design if available, or create from scratch
+- Consider integration with existing systems and architecture
+- Address scalability, maintainability, and performance requirements
+
+Begin by analyzing the repository structure to understand the current technology stack, then create the comprehensive technical design.`;
+};

package/dist/services/checklist.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Checklist service for pipeline integration
+ */
+import { PipelinePhaseOptions } from '../types/pipeline.js';
+export interface ChecklistItem {
+    id: string;
+    title: string;
+    description: string;
+    item_type: 'boolean' | 'text' | 'number' | 'select';
+    is_required: boolean;
+    sort_order: number;
+    config: Record<string, any>;
+}
+export interface Checklist {
+    id: string;
+    product_id: string;
+    feature_id: string | null;
+    name: string;
+    description: string | null;
+    role: string;
+    phase: string;
+    is_active: boolean;
+    sort_order: number;
+    created_at: string;
+    updated_at: string;
+    items: ChecklistItem[];
+}
+export interface ChecklistValidation {
+    checklist_id: string;
+    checklist_name: string;
+    role: string;
+    is_completed: boolean;
+    completed_at: string | null;
+    status: 'not_started' | 'pending' | 'in_progress' | 'completed' | 'skipped';
+}
+export interface ChecklistPhaseContext {
+    phase: string;
+    feature_id: string;
+    checklists: Checklist[];
+}
+export interface ChecklistValidationResult {
+    phase: string;
+    feature_id: string;
+    all_completed: boolean;
+    checklists_validation: ChecklistValidation[];
+    summary: string;
+}
+/**
+ * Fetch checklists for a specific phase
+ */
+export declare function getChecklistsForPhase(options: PipelinePhaseOptions, phase: string): Promise<ChecklistPhaseContext>;
+/**
+ * Validate checklist completion for a phase
+ */
+export declare function validateChecklistsForPhase(options: PipelinePhaseOptions, phase: string): Promise<ChecklistValidationResult>;
+/**
+ * Create checklist results (mark as started/in-progress)
+ */
+export declare function createChecklistResult(options: PipelinePhaseOptions, checklistId: string, itemResults?: any[]): Promise<any>;
+/**
+ * Strictly validate that all required checklists have results
+ * Returns error if any checklists exist but don't have results
+ */
+export declare function validateRequiredChecklistResults(options: PipelinePhaseOptions, phase: string, verbose?: boolean): Promise<{
+    success: boolean;
+    error?: string;
+    missingChecklists: string[];
+}>;
+/**
+ * Create checklist item result
+ */
+export declare function createChecklistItemResult(options: PipelinePhaseOptions, checklistItemId: string, isPassed: boolean, value?: any, notes?: string): Promise<any>;
+/**
+ * Process checklist item results from phase JSON response and create MCP results
+ */
+export declare function processChecklistItemResultsFromResponse(options: PipelinePhaseOptions, phase: string, checklistItemResults?: Array<{
+    checklist_item_id: string;
+    is_passed: boolean;
+    value?: any;
+    notes?: string;
+}>, verbose?: boolean): Promise<{
+    created: number;
+    errors: string[];
+}>;
+/**
+ * Process checklist results from phase JSON response and create MCP results
+ */
+export declare function processChecklistResultsFromResponse(options: PipelinePhaseOptions, checklistResults?: Array<{
+    checklist_id: string;
+    satisfied: boolean;
+    notes?: string;
+}>, verbose?: boolean): Promise<{
+    created: number;
+    errors: string[];
+}>;
+/**
+ * Format checklist context as string for LLM consumption
+ */
+export declare function formatChecklistsForContext(context: ChecklistPhaseContext): string;

package/dist/services/checklist.js

@@ -0,0 +1,337 @@
+/**
+ * Checklist service for pipeline integration
+ */
+/**
+ * Fetch checklists for a specific phase
+ */
+export async function getChecklistsForPhase(options, phase) {
+    const { mcpServerUrl, mcpToken, featureId } = options;
+    // Convert phase name from hyphen to underscore format for database compatibility
+    // e.g., 'feature-analysis' -> 'feature_analysis'
+    const dbPhase = phase.replace(/-/g, '_');
+    // Log the request details for debugging
+    const requestBody = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'checklists/phase',
+        params: {
+            feature_id: featureId,
+            phase: dbPhase, // Use underscore format for database
+        },
+    };
+    console.log(`🔍 Fetching checklists: phase="${phase}" (db: "${dbPhase}"), feature_id="${featureId}"`);
+    const response = await fetch(`${mcpServerUrl}/mcp`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${mcpToken}`,
+        },
+        body: JSON.stringify(requestBody),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to fetch checklists for phase "${phase}": ${response.status} ${response.statusText}. Response: ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+        throw new Error(`MCP Error for phase "${phase}": ${data.error.message || JSON.stringify(data.error)}`);
+    }
+    // Handle empty result gracefully
+    if (!data.result) {
+        return {
+            phase,
+            feature_id: featureId,
+            checklists: [],
+        };
+    }
+    return data.result;
+}
+/**
+ * Validate checklist completion for a phase
+ */
+export async function validateChecklistsForPhase(options, phase) {
+    const { mcpServerUrl, mcpToken, featureId } = options;
+    // Convert phase name from hyphen to underscore format for database compatibility
+    const dbPhase = phase.replace(/-/g, '_');
+    const response = await fetch(`${mcpServerUrl}/mcp`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${mcpToken}`,
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'checklists/validate',
+            params: {
+                feature_id: featureId,
+                phase: dbPhase, // Use underscore format for database
+            },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to validate checklists for phase: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+        throw new Error(`MCP Error: ${data.error.message}`);
+    }
+    return data.result;
+}
+/**
+ * Create checklist results (mark as started/in-progress)
+ */
+export async function createChecklistResult(options, checklistId, itemResults) {
+    const { mcpServerUrl, mcpToken, featureId } = options;
+    const response = await fetch(`${mcpServerUrl}/mcp`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${mcpToken}`,
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'checklist_results/create',
+            params: {
+                feature_id: featureId,
+                checklist_id: checklistId,
+                item_results: itemResults,
+            },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to create checklist result: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+        throw new Error(`MCP Error: ${data.error.message}`);
+    }
+    return data.result;
+}
+/**
+ * Strictly validate that all required checklists have results
+ * Returns error if any checklists exist but don't have results
+ */
+export async function validateRequiredChecklistResults(options, phase, verbose) {
+    try {
+        // Get checklists for this phase
+        const checklistContext = await getChecklistsForPhase(options, phase);
+        // If no checklists exist for this phase, validation passes
+        if (!checklistContext.checklists ||
+            checklistContext.checklists.length === 0) {
+            if (verbose) {
+                console.log(`📋 No checklists found for phase ${phase} - validation passes`);
+            }
+            return { success: true, missingChecklists: [] };
+        }
+        // Validate checklist completion
+        const validation = await validateChecklistsForPhase(options, phase);
+        const missingChecklists = [];
+        // Check each checklist to ensure it has been addressed with results
+        for (const checklistValidation of validation.checklists_validation) {
+            // If checklist exists but has no result created (status is 'not_started')
+            if (checklistValidation.status === 'not_started') {
+                missingChecklists.push(checklistValidation.checklist_name);
+            }
+        }
+        if (missingChecklists.length > 0) {
+            const errorMsg = `Phase ${phase} has ${checklistContext.checklists.length} MANDATORY checklists but ${missingChecklists.length} are missing results. All checklists must be addressed. Missing: ${missingChecklists.join(', ')}`;
+            if (verbose) {
+                console.log(`❌ ${errorMsg}`);
+            }
+            return {
+                success: false,
+                error: errorMsg,
+                missingChecklists,
+            };
+        }
+        if (verbose) {
+            console.log(`✅ All ${validation.checklists_validation.length} mandatory checklists for phase ${phase} have been addressed`);
+        }
+        return { success: true, missingChecklists: [] };
+    }
+    catch (error) {
+        const errorMsg = `Failed to validate mandatory checklist compliance for phase ${phase}: ${error instanceof Error ? error.message : String(error)}`;
+        return {
+            success: false,
+            error: errorMsg,
+            missingChecklists: [],
+        };
+    }
+}
+/**
+ * Create checklist item result
+ */
+export async function createChecklistItemResult(options, checklistItemId, isPassed, value, notes) {
+    const { mcpServerUrl, mcpToken, featureId } = options;
+    const response = await fetch(`${mcpServerUrl}/mcp`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${mcpToken}`,
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'checklist_item_results/create',
+            params: {
+                feature_id: featureId,
+                checklist_item_id: checklistItemId,
+                is_passed: isPassed,
+                value: value,
+                notes: notes,
+            },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to create checklist item result: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+        throw new Error(`MCP Error: ${data.error.message}`);
+    }
+    return data.result;
+}
+/**
+ * Process checklist item results from phase JSON response and create MCP results
+ */
+export async function processChecklistItemResultsFromResponse(options, phase, checklistItemResults, verbose) {
+    const errors = [];
+    let created = 0;
+    if (!checklistItemResults || checklistItemResults.length === 0) {
+        if (verbose) {
+            console.log('📋 No checklist item results to process');
+        }
+        return { created, errors };
+    }
+    // Get current checklists to map checklist_item_id to checklist_id
+    const checklistContext = await getChecklistsForPhase(options, phase);
+    // Create a map from checklist_item_id to checklist_id
+    const itemToChecklistMap = new Map();
+    const checklistIds = new Set();
+    for (const checklist of checklistContext.checklists) {
+        checklistIds.add(checklist.id);
+        for (const item of checklist.items) {
+            itemToChecklistMap.set(item.id, checklist.id);
+        }
+    }
+    // Group checklist item results by checklist
+    const resultsByChecklist = new Map();
+    for (const result of checklistItemResults) {
+        const checklistId = itemToChecklistMap.get(result.checklist_item_id);
+        if (!checklistId) {
+            const errorMsg = `Could not find checklist for item ${result.checklist_item_id}`;
+            errors.push(errorMsg);
+            if (verbose) {
+                console.log(`❌ ${errorMsg}`);
+            }
+            continue;
+        }
+        if (!resultsByChecklist.has(checklistId)) {
+            resultsByChecklist.set(checklistId, []);
+        }
+        resultsByChecklist.get(checklistId).push({
+            checklist_item_id: result.checklist_item_id,
+            is_passed: result.is_passed,
+            value: result.value,
+            notes: result.notes,
+        });
+    }
+    // Create checklist results with item results for each checklist
+    for (const [checklistId, itemResults] of resultsByChecklist) {
+        try {
+            await createChecklistResult(options, checklistId, itemResults);
+            created += itemResults.length;
+            if (verbose) {
+                console.log(`📋 Created checklist result for ${checklistId} with ${itemResults.length} item results`);
+                for (const itemResult of itemResults) {
+                    const status = itemResult.is_passed ? '✅' : '❌';
+                    console.log(`  ${status} Item: ${itemResult.checklist_item_id}`);
+                    if (itemResult.notes) {
+                        console.log(`     Notes: ${itemResult.notes}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const errorMsg = `Failed to create checklist result for ${checklistId}: ${error instanceof Error ? error.message : String(error)}`;
+            errors.push(errorMsg);
+            if (verbose) {
+                console.log(`❌ ${errorMsg}`);
+            }
+        }
+    }
+    return { created, errors };
+}
+/**
+ * Process checklist results from phase JSON response and create MCP results
+ */
+export async function processChecklistResultsFromResponse(options, checklistResults, verbose) {
+    const errors = [];
+    let created = 0;
+    if (!checklistResults || checklistResults.length === 0) {
+        if (verbose) {
+            console.log('📋 No checklist results to process');
+        }
+        return { created, errors };
+    }
+    for (const result of checklistResults) {
+        if (result.satisfied) {
+            try {
+                await createChecklistResult(options, result.checklist_id);
+                created++;
+                if (verbose) {
+                    console.log(`✅ Created checklist result for: ${result.checklist_id}`);
+                    if (result.notes) {
+                        console.log(`   Notes: ${result.notes}`);
+                    }
+                }
+            }
+            catch (error) {
+                const errorMsg = `Failed to create checklist result for ${result.checklist_id}: ${error instanceof Error ? error.message : String(error)}`;
+                errors.push(errorMsg);
+                if (verbose) {
+                    console.log(`❌ ${errorMsg}`);
+                }
+            }
+        }
+        else {
+            // For unsatisfied checklists, still create a result but mark as failed/incomplete
+            if (verbose) {
+                console.log(`⚠️  Checklist ${result.checklist_id} marked as NOT satisfied`);
+                if (result.notes) {
+                    console.log(`   Reason: ${result.notes}`);
+                }
+            }
+            // Note: We still need to create some form of result to track that this checklist was addressed
+            // but marked as unsatisfied. The current MCP API might need to support this case.
+        }
+    }
+    return { created, errors };
+}
+/**
+ * Format checklist context as string for LLM consumption
+ */
+export function formatChecklistsForContext(context) {
+    if (!context.checklists || context.checklists.length === 0) {
+        return `No checklists defined for phase: ${context.phase}`;
+    }
+    const sections = context.checklists
+        .map((checklist) => {
+        const itemsText = checklist.items
+            .map((item) => `  - **${item.title}** (ID: ${item.id})${item.is_required ? ' (required)' : ''}: ${item.description || 'No description'}`)
+            .join('\n');
+        return `**${checklist.name}** (${checklist.role})
+ID: ${checklist.id}
+${checklist.description || 'No description'}
+Items:
+${itemsText}`;
+    })
+        .join('\n\n');
+    return `# Checklists for ${context.phase} phase
+
+${sections}
+
+Please review these checklists and ensure your work addresses the relevant requirements for your role. These checklists will be used to validate the completion of this phase.`;
+}

package/dist/types/features.d.ts

@@ -0,0 +1,29 @@
+export interface FeatureInfo {
+    id: string;
+    name: string;
+    description?: string;
+    technical_design?: string;
+    status: string;
+    product_id: string;
+    execution_mode?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface UserStory {
+    id: string;
+    title: string;
+    description: string;
+    status: string;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: any;
+}
+export interface TestCase {
+    id: string;
+    name: string;
+    description: string;
+    is_critical: boolean;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: any;
+}

package/dist/types/features.js

@@ -0,0 +1 @@
+export {};