edsger 0.2.1 → 0.2.2

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 {};

package/dist/types/index.d.ts

@@ -0,0 +1,112 @@
+export interface EdsgerConfig {
+    patterns: string[];
+    exclude: string[];
+    severity: 'error' | 'warning';
+    maxFiles: number;
+    claude: {
+        model?: string;
+        timeout?: number;
+    };
+}
+export interface GitFile {
+    path: string;
+    content: string;
+    status: 'modified' | 'added' | 'deleted' | 'renamed';
+}
+export interface ReviewResult {
+    file: string;
+    status: 'OK' | 'WARN' | 'BLOCK';
+    message: string;
+    details?: string;
+}
+export interface CliOptions {
+    review?: boolean;
+    staged?: boolean;
+    files?: string[];
+    config?: string;
+    verbose?: boolean;
+    featureAnalysis?: string;
+    technicalDesign?: string;
+    implement?: string;
+    test?: string;
+    workflow?: boolean;
+}
+export type ReviewSeverity = 'error' | 'warning';
+export type ExitCode = 0 | 1;
+export interface FeatureAnalysisResult {
+    featureId: string;
+    productInfo: unknown;
+    featureInfo: unknown;
+    existingUserStories: UserStory[];
+    existingTestCases: TestCase[];
+    createdUserStories: UserStory[];
+    createdTestCases: TestCase[];
+    summary: string;
+    status: 'pending' | 'success' | 'error';
+    data?: {
+        checklist_results?: Array<{
+            checklist_id: string;
+            satisfied: boolean;
+            notes?: string;
+        }>;
+        checklist_item_results?: Array<{
+            checklist_item_id: string;
+            is_passed: boolean;
+            value?: any;
+            notes?: string;
+        }>;
+    };
+}
+export interface FeatureData {
+    feature: {
+        id: string;
+        name: string;
+        description: string;
+        status: string;
+        product_id: string;
+        created_at: string;
+        updated_at: string;
+    };
+    product: {
+        id: string;
+        name: string;
+        description: string;
+        status: string;
+        features: unknown[];
+        metadata: {
+            created_at: string;
+            updated_at: string;
+        };
+    };
+}
+export interface UserStory {
+    id: string;
+    title: string;
+    description: string;
+    status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled';
+    created_at: string;
+    updated_at: string;
+}
+export interface TestCase {
+    id: string;
+    name: string;
+    description: string;
+    is_critical: boolean;
+    created_at: string;
+    updated_at: string;
+}
+export interface DisplayUserStory {
+    title: string;
+}
+export interface DisplayTestCase {
+    name: string;
+    is_critical?: boolean;
+}
+export interface FeatureAnalysisDisplayResult {
+    featureId: string;
+    status: string;
+    summary?: string;
+    createdUserStories?: DisplayUserStory[];
+    createdTestCases?: DisplayTestCase[];
+}
+export type FeatureStatus = 'backlog' | 'ready_for_dev' | 'feature_analysis' | 'technical_design' | 'code_implementation' | 'code_review' | 'ready_for_review' | 'shipped' | 'testing_in_progress' | 'testing_passed' | 'testing_failed';

package/dist/types/index.js

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

package/dist/types/pipeline.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Type definitions for pipeline execution
+ */
+import { EdsgerConfig } from './index.js';
+import { ChecklistPhaseContext } from '../services/checklist.js';
+export type ExecutionMode = 'full_pipeline' | 'only_feature_analysis' | 'only_technical_design' | 'only_code_implementation' | 'only_functional_testing' | 'from_feature_analysis' | 'from_technical_design' | 'from_code_implementation' | 'from_functional_testing';
+export interface PipelinePhaseOptions {
+    readonly featureId: string;
+    readonly mcpServerUrl: string;
+    readonly mcpToken: string;
+    readonly verbose?: boolean;
+}
+export interface PipelineResult {
+    readonly featureId: string;
+    readonly phase: string;
+    readonly status: 'success' | 'error';
+    readonly message: string;
+    readonly data?: unknown;
+}
+export interface PhaseConfig {
+    readonly name: string;
+    readonly checkRequirements: () => Promise<boolean>;
+    readonly execute: (options: PipelinePhaseOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<any>;
+    readonly requirementsError: string;
+}

package/dist/types/pipeline.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for pipeline execution
+ */
+export {};

package/dist/utils/logger.d.ts

@@ -0,0 +1,19 @@
+import { ReviewResult } from '../types/index.js';
+export declare const colors: {
+    reset: string;
+    bright: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    gray: string;
+};
+export declare const colorize: (text: string, color: keyof typeof colors) => string;
+export declare const logInfo: (message: string) => void;
+export declare const logSuccess: (message: string) => void;
+export declare const logWarning: (message: string) => void;
+export declare const logError: (message: string) => void;
+export declare const logProgress: (current: number, total: number, file: string) => void;
+export declare const logResults: (results: ReviewResult[], verbose?: boolean) => void;

package/dist/utils/logger.js

@@ -0,0 +1,52 @@
+export const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m'
+};
+export const colorize = (text, color) => {
+    return `${colors[color]}${text}${colors.reset}`;
+};
+export const logInfo = (message) => {
+    console.log(colorize(`ℹ ${message}`, 'blue'));
+};
+export const logSuccess = (message) => {
+    console.log(colorize(`✓ ${message}`, 'green'));
+};
+export const logWarning = (message) => {
+    console.log(colorize(`⚠ ${message}`, 'yellow'));
+};
+export const logError = (message) => {
+    console.error(colorize(`✗ ${message}`, 'red'));
+};
+export const logProgress = (current, total, file) => {
+    const percentage = Math.round((current / total) * 100);
+    const progress = `[${current}/${total}] ${percentage}%`;
+    console.log(colorize(`${progress} Reviewing ${file}`, 'gray'));
+};
+export const logResults = (results, verbose = false) => {
+    const okCount = results.filter(r => r.status === 'OK').length;
+    const warnCount = results.filter(r => r.status === 'WARN').length;
+    const blockCount = results.filter(r => r.status === 'BLOCK').length;
+    console.log('\n' + colorize('='.repeat(60), 'gray'));
+    console.log(colorize('Review Results', 'bright'));
+    console.log(colorize('='.repeat(60), 'gray'));
+    results.forEach(result => {
+        const icon = result.status === 'OK' ? '✓' : result.status === 'WARN' ? '⚠' : '✗';
+        const color = result.status === 'OK' ? 'green' : result.status === 'WARN' ? 'yellow' : 'red';
+        console.log(colorize(`${icon} ${result.file}: ${result.message}`, color));
+        if (verbose && result.details && result.status !== 'OK') {
+            console.log(colorize(`   Details: ${result.details}`, 'gray'));
+        }
+    });
+    console.log('\n' + colorize('Summary:', 'bright'));
+    console.log(colorize(`  ✓ Passed: ${okCount}`, 'green'));
+    console.log(colorize(`  ⚠ Warnings: ${warnCount}`, 'yellow'));
+    console.log(colorize(`  ✗ Blocked: ${blockCount}`, 'red'));
+    console.log(colorize(`  Total: ${results.length} files reviewed`, 'gray'));
+};

package/dist/utils/pipeline-logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Logging utilities for pipeline execution
+ */
+import { PipelineResult } from '../types/pipeline.js';
+export declare const logPipelineStart: (featureId: string, verbose?: boolean) => void;
+export declare const logPhaseResult: (result: PipelineResult, verbose?: boolean) => PipelineResult;
+export declare const logPipelineComplete: (results: readonly PipelineResult[], verbose?: boolean) => readonly PipelineResult[];
+export declare const shouldContinuePipeline: (results: readonly PipelineResult[]) => boolean;

package/dist/utils/pipeline-logger.js

@@ -0,0 +1,35 @@
+/**
+ * Logging utilities for pipeline execution
+ */
+// Pipeline execution utilities
+export const logPipelineStart = (featureId, verbose) => {
+    if (verbose) {
+        console.log(`🚀 Starting complete pipeline for feature: ${featureId}`);
+        console.log('📋 Pipeline phases: feature-analysis → technical-design → code-implementation → functional-testing');
+    }
+};
+export const logPhaseResult = (result, verbose) => {
+    if (verbose) {
+        const statusIcon = result.status === 'success' ? '✅' : '❌';
+        console.log(`${statusIcon} ${result.phase}: ${result.message}`);
+    }
+    return result;
+};
+export const logPipelineComplete = (results, verbose) => {
+    if (verbose) {
+        const lastResult = results[results.length - 1];
+        const featureId = lastResult?.featureId;
+        if (lastResult?.status === 'success') {
+            console.log(`✅ Complete pipeline finished successfully for feature: ${featureId}`);
+        }
+        else {
+            console.log(`❌ Pipeline failed at ${lastResult?.phase}: ${lastResult?.message}`);
+        }
+    }
+    return results;
+};
+// Pure function to check if pipeline should continue
+export const shouldContinuePipeline = (results) => {
+    const lastResult = results[results.length - 1];
+    return lastResult?.status === 'success';
+};

package/dist/workflow-runner/config/phase-configs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Phase configurations for the pipeline runner
+ */
+import { PhaseConfig } from '../../types/pipeline.js';
+export declare const phaseConfigs: readonly PhaseConfig[];

package/dist/workflow-runner/config/phase-configs.js

@@ -0,0 +1,34 @@
+/**
+ * Phase configurations for the pipeline runner
+ */
+import { analyzeFeatureWithMCP, checkFeatureAnalysisRequirements, } from '../../phases/feature-analysis/analyzer.js';
+import { generateTechnicalDesign, checkTechnicalDesignRequirements, } from '../../phases/technical-design/analyzer.js';
+import { implementFeatureCode, checkCodeImplementationRequirements, } from '../../phases/code-implementation/analyzer.js';
+import { runFunctionalTesting, checkFunctionalTestingRequirements, } from '../../phases/functional-testing/analyzer.js';
+// Pipeline phase configurations
+export const phaseConfigs = [
+    {
+        name: 'feature-analysis',
+        checkRequirements: checkFeatureAnalysisRequirements,
+        execute: analyzeFeatureWithMCP,
+        requirementsError: 'Feature analysis requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+    {
+        name: 'technical-design',
+        checkRequirements: checkTechnicalDesignRequirements,
+        execute: generateTechnicalDesign,
+        requirementsError: 'Technical design requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+    {
+        name: 'code-implementation',
+        checkRequirements: checkCodeImplementationRequirements,
+        execute: implementFeatureCode,
+        requirementsError: 'Code implementation requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+    {
+        name: 'functional-testing',
+        checkRequirements: checkFunctionalTestingRequirements,
+        execute: runFunctionalTesting,
+        requirementsError: 'Functional testing requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
+    },
+];

package/dist/workflow-runner/config/stage-configs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Stage configurations for the pipeline runner
+ */
+import { StageConfig } from '../../types/pipeline.js';
+export declare const stageConfigs: readonly StageConfig[];