edsger 0.2.3 → 0.2.5

package/dist/cli.js

@@ -1,100 +1,5 @@
 #!/usr/bin/env node
-var _a, _b, _c;
-import { Command } from 'commander';
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { config as dotenvConfig } from 'dotenv';
-import { logError } from './utils/logger.js';
-import { runWorkflow } from './cli/commands/workflow-command.js';
-import { runFeatureAnalysis } from './cli/commands/feature-analysis-command.js';
-import { runTechnicalDesign } from './cli/commands/technical-design-command.js';
-import { runCodeImplementation } from './cli/commands/code-implementation-command.js';
-import { runFunctionalTestingCommand } from './cli/commands/functional-testing-command.js';
-import { runCodeReview } from './cli/commands/code-review-command.js';
-// Get package.json version dynamically
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
-const version = packageJson.version;
-// Load environment variables from .env file
-// Load from current working directory (where the command is run)
-dotenvConfig({ path: join(process.cwd(), '.env') });
-const program = new Command();
-program
-    .name('edsger')
-    .description('AI-powered code review CLI tool using Claude Code SDK')
-    .version(version);
-program
-    .option('-r, --review', 'Review code changes')
-    .option('-s, --staged', 'Review only staged changes')
-    .option('-f, --files <patterns...>', 'Review specific file patterns')
-    .option('--feature-analysis <featureId>', 'Analyze feature and generate user stories/test cases')
-    .option('--technical-design <featureId>', 'Generate technical design for a feature')
-    .option('--implement <featureId>', 'Implement code for a feature based on its specifications')
-    .option('--test <featureId>', 'Run functional tests for a feature using Playwright')
-    .option('--workflow', 'Run continuous workflow processor to handle ready_for_dev features')
-    .option('-c, --config <path>', 'Path to config file')
-    .option('-v, --verbose', 'Verbose output');
-program.action(async (options) => {
-    try {
-        await runEdsger(options);
-    }
-    catch (error) {
-        logError(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-});
-export const runEdsger = async (options) => {
-    // Handle workflow mode
-    if (options.workflow) {
-        await runWorkflow(options);
-        return;
-    }
-    // Handle feature analysis mode
-    if (options.featureAnalysis) {
-        await runFeatureAnalysis(options);
-        return;
-    }
-    // Handle technical design mode
-    if (options.technicalDesign) {
-        await runTechnicalDesign(options);
-        return;
-    }
-    // Handle code implementation mode
-    if (options.implement) {
-        await runCodeImplementation(options);
-        return;
-    }
-    // Handle functional testing mode
-    if (options.test) {
-        await runFunctionalTestingCommand(options);
-        return;
-    }
-    // Handle code review mode (explicit --review flag or as fallback)
-    if (options.review || options.staged || options.files) {
-        await runCodeReview(options);
-        return;
-    }
-    // Default to workflow mode if environment is configured, otherwise code review
-    const productId = process.env.EDSGER_PRODUCT_ID;
-    const mcpToken = process.env.EDSGER_MCP_TOKEN;
-    if (productId && mcpToken) {
-        // Environment is configured for workflow, use that as default
-        options.workflow = true;
-        await runWorkflow(options);
-    }
-    else {
-        // Default to code review mode
-        await runCodeReview(options);
-    }
-};
-// Only parse when this file is run directly (not imported as module)
-// Check if this is the main module being executed
-const isMainModule = import.meta.url === `file://${process.argv[1]}` ||
-    ((_a = process.argv[1]) === null || _a === void 0 ? void 0 : _a.endsWith('/edsger')) ||
-    ((_b = process.argv[1]) === null || _b === void 0 ? void 0 : _b.endsWith('\\edsger')) ||
-    ((_c = process.argv[1]) === null || _c === void 0 ? void 0 : _c.endsWith('cli.js'));
-if (isMainModule) {
-    program.parse();
-}
+// Re-export the CLI module
+export * from './cli/index.js';
+// Import and trigger the CLI parsing if this file is run directly
+import './cli/index.js';

package/dist/phases/code-implementation/analyzer-helpers.d.ts

@@ -0,0 +1,28 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { ChecklistVerificationResult } from '../code-implementation-verification/index.js';
+import { CodeImplementationResult } from './analyzer.js';
+export interface VerificationCycleResult {
+    passed: boolean;
+    verificationResult: ChecklistVerificationResult | null;
+    nextPrompt: string | null;
+}
+/**
+ * Perform a complete verification cycle:
+ * 1. Verify code implementation against checklist
+ * 2. Log results to audit logs
+ * 3. Create improvement prompt if verification failed
+ */
+export declare function performVerificationCycle(branchName: string, baseBranch: string, checklistContext: ChecklistPhaseContext | null, featureId: string, featureName: string, featureDescription: string | undefined, config: EdsgerConfig, currentIteration: number, maxIterations: number, mcpServerUrl: string, mcpToken: string, verbose?: boolean): Promise<VerificationCycleResult>;
+/**
+ * Build successful implementation result
+ */
+export declare function buildImplementationResult(featureId: string, branchName: string, implementationSummary: string, filesModified: string[], commitHash: string, iterations: number, checklistResults?: any[], checklistItemResults?: any[]): CodeImplementationResult;
+/**
+ * Build verification failure result
+ */
+export declare function buildVerificationFailureResult(featureId: string, branchName: string, implementationSummary: string, filesModified: string[], commitHash: string, verificationResult: ChecklistVerificationResult, iterations: number): CodeImplementationResult;
+/**
+ * Build error result for no implementation
+ */
+export declare function buildNoResultsError(featureId: string, branchName: string): CodeImplementationResult;

package/dist/phases/code-implementation/analyzer-helpers.js

@@ -0,0 +1,177 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
+import { formatChecklistsForContext, processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
+import { verifyCodeImplementationCompliance, } from '../code-implementation-verification/index.js';
+import { createCodeImplementationImprovementPrompt } from '../../prompts/code-implementation-improvement.js';
+/**
+ * Perform a complete verification cycle:
+ * 1. Verify code implementation against checklist
+ * 2. Log results to audit logs
+ * 3. Create improvement prompt if verification failed
+ */
+export async function performVerificationCycle(branchName, baseBranch, checklistContext, featureId, featureName, featureDescription, config, currentIteration, maxIterations, mcpServerUrl, mcpToken, verbose) {
+    // If no checklist, verification passes automatically
+    if (!checklistContext || checklistContext.checklists.length === 0) {
+        if (verbose) {
+            logInfo('ℹ️  No checklists to verify - skipping verification');
+        }
+        return {
+            passed: true,
+            verificationResult: null,
+            nextPrompt: null,
+        };
+    }
+    if (verbose) {
+        logInfo(`\n🔍 Verifying code implementation (iteration ${currentIteration}/${maxIterations})...`);
+    }
+    // Format checklist context for verification
+    const checklistInfo = formatChecklistsForContext(checklistContext);
+    // Perform verification
+    const verificationResult = await verifyCodeImplementationCompliance({
+        featureId,
+        branchName,
+        baseBranch,
+        featureName,
+        featureDescription,
+        checklistContext: checklistInfo,
+        verbose,
+    }, config);
+    // Determine if verification passed
+    const verificationPassed = verificationResult.rejected_count === 0;
+    // Log verification result
+    if (verificationPassed) {
+        if (verbose) {
+            logInfo(`✅ Code verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
+        }
+        await logFeatureVerificationEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            phase: 'code_implementation',
+            iteration: currentIteration,
+            result: 'success',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                summary: verificationResult.summary,
+            },
+        }, verbose);
+        // Create checklist results based on verification result
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId, mcpServerUrl, mcpToken }, 'code_implementation', checklistItemResults, verbose);
+    }
+    else {
+        logError(`❌ Iteration ${currentIteration}: Code verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
+        await logFeatureVerificationEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            phase: 'code_implementation',
+            iteration: currentIteration,
+            result: 'error',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                rejected_items: verificationResult.item_verifications
+                    .filter((item) => item.verification_status === 'rejected')
+                    .map((item) => ({
+                    checklist_item_id: item.checklist_item_id,
+                    reason: item.verification_reason || 'No reason provided',
+                    concerns: item.concerns || [],
+                    improvement_suggestions: item.improvement_suggestions || [],
+                })),
+                uncertain_items: verificationResult.item_verifications
+                    .filter((item) => item.verification_status === 'uncertain')
+                    .map((item) => ({
+                    checklist_item_id: item.checklist_item_id,
+                    reason: item.verification_reason || 'No reason provided',
+                    concerns: item.concerns || [],
+                    improvement_suggestions: item.improvement_suggestions || [],
+                })),
+                summary: verificationResult.summary,
+                overall_suggestions: verificationResult.overall_suggestions || [],
+            },
+        }, verbose);
+    }
+    // If verification failed and we have iterations left, create improvement prompt
+    let nextPrompt = null;
+    if (!verificationPassed && currentIteration < maxIterations) {
+        nextPrompt = createCodeImplementationImprovementPrompt(verificationResult, branchName, baseBranch);
+        if (verbose) {
+            logInfo(`\n📝 Created improvement prompt for next iteration (${maxIterations - currentIteration} attempts remaining)`);
+        }
+    }
+    else if (!verificationPassed) {
+        // Max iterations reached - create checklist results based on final verification
+        if (verbose) {
+            logInfo(`\n📋 Creating checklist results for final iteration (max iterations reached)`);
+        }
+        // Create checklist results for all items (both passed and failed)
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId, mcpServerUrl, mcpToken }, 'code_implementation', checklistItemResults, verbose);
+    }
+    return {
+        passed: verificationPassed,
+        verificationResult,
+        nextPrompt,
+    };
+}
+/**
+ * Build successful implementation result
+ */
+export function buildImplementationResult(featureId, branchName, implementationSummary, filesModified, commitHash, iterations, checklistResults, checklistItemResults) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary,
+        status: 'success',
+        message: 'Code implementation completed successfully',
+        filesModified,
+        commitHash,
+        data: {
+            checklist_results: checklistResults,
+            checklist_item_results: checklistItemResults,
+        },
+    };
+}
+/**
+ * Build verification failure result
+ */
+export function buildVerificationFailureResult(featureId, branchName, implementationSummary, filesModified, commitHash, verificationResult, iterations) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary,
+        status: 'error',
+        message: `Code implementation verification failed after ${iterations} iterations. Code committed for manual review.`,
+        filesModified,
+        commitHash,
+        data: {
+            verification_failed: true,
+            verification_summary: verificationResult.summary,
+            rejected_count: verificationResult.rejected_count,
+            uncertain_count: verificationResult.uncertain_count,
+            improvement_suggestions: verificationResult.overall_suggestions || [],
+        },
+    };
+}
+/**
+ * Build error result for no implementation
+ */
+export function buildNoResultsError(featureId, branchName) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary: null,
+        status: 'error',
+        message: 'Code implementation failed - no results produced',
+    };
+}

package/dist/phases/code-implementation/analyzer.d.ts

@@ -6,6 +6,7 @@ export interface CodeImplementationOptions {
     mcpToken: string;
     verbose?: boolean;
     baseBranch?: string;
+    maxVerificationIterations?: number;
 }
 export interface CodeImplementationResult {
     featureId: string;
@@ -27,6 +28,7 @@ export interface CodeImplementationResult {
             value?: any;
             notes?: string;
         }>;
+        [key: string]: any;
     };
 }
 export declare const implementFeatureCode: (options: CodeImplementationOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<CodeImplementationResult>;