edsger 0.41.1 → 0.41.3

package/dist/index.js

@@ -16,10 +16,10 @@ import { runConfigGet, runConfigList, runConfigSet, runConfigUnset, } from './co
 import { runGrowthAnalysis } from './commands/growth-analysis/index.js';
 import { runInit } from './commands/init/index.js';
 import { runIntelligence } from './commands/intelligence/index.js';
+import { runPRResolve } from './commands/pr-resolve/index.js';
+import { runPRReview } from './commands/pr-review/index.js';
 import { runRefactor } from './commands/refactor/refactor.js';
 import { runTaskWorker } from './commands/task-worker/index.js';
-import { runPRReview } from './commands/pr-review/index.js';
-import { runPRResolve } from './commands/pr-resolve/index.js';
 import { runWorkflow } from './commands/workflow/index.js';
 import { logError, logInfo } from './utils/logger.js';
 // Get package.json version dynamically

package/dist/phases/app-store-generation/index.js

@@ -13,9 +13,7 @@ function truncateKeywords(keywords) {
     }
     return keywords.slice(0, 100).replace(/,[^,]*$/, '');
 }
-export const generateAppStoreAssets = async (options, config
-// eslint-disable-next-line complexity -- orchestration function with sequential asset generation steps
-) => {
+export const generateAppStoreAssets = async (options, config) => {
     const { productId, targetStore, screenshotsOnly, listingsOnly, verbose } = options;
     if (verbose) {
         logInfo(`Starting app store generation for product: ${productId}`);

package/dist/phases/branch-planning/index.js

@@ -116,9 +116,7 @@ async function persistBranches(sortedBranches, featureId, verbose) {
         }
     }
 }
-export const planFeatureBranches = async (options, config
-// eslint-disable-next-line complexity -- orchestration function with context fetching, agent execution, and result processing
-) => {
+export const planFeatureBranches = async (options, config) => {
     const { featureId, verbose, replaceExisting } = options;
     if (verbose) {
         logInfo(`Starting branch planning for feature ID: ${featureId}`);

package/dist/phases/bug-fixing/analyzer.js

@@ -32,9 +32,7 @@ async function* prompt(bugFixPrompt) {
         setTimeout(res, 10000);
     });
 }
-export const fixTestFailures = async (options, config
-// eslint-disable-next-line complexity -- orchestration function with agent setup, message processing, and result extraction
-) => {
+export const fixTestFailures = async (options, config) => {
     const { featureId, testErrors, attemptNumber = 1, verbose } = options;
     if (verbose) {
         logInfo(`Starting bug fixing for feature ID: ${featureId} (Attempt ${attemptNumber})`);

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/agent.js';
+import { CodeImplementationResult } from './index.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, 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/agent.js';
+import { createCodeImplementationImprovementPrompt } from './prompts.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, 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({
+            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 }, 'code_implementation', checklistItemResults, verbose);
+    }
+    else {
+        logError(`❌ Iteration ${currentIteration}: Code verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
+        await logFeatureVerificationEvent({
+            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 }, '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

@@ -0,0 +1,32 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface CodeImplementationOptions {
+    featureId: string;
+    verbose?: boolean;
+    baseBranch?: string;
+    maxVerificationIterations?: number;
+}
+export interface CodeImplementationResult {
+    featureId: string;
+    branchName: string;
+    implementationSummary: string | null;
+    status: 'success' | 'error';
+    message: string;
+    filesModified?: string[];
+    commitHash?: string;
+    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;
+        }>;
+        [key: string]: any;
+    };
+}
+export declare const implementFeatureCode: (options: CodeImplementationOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<CodeImplementationResult>;