edsger 0.30.0 → 0.30.2

package/dist/phases/autonomous/index.js

@@ -14,6 +14,7 @@ import { createBranches, getCurrentBranch, updateBranch, } from '../../services/
 import { prepareCustomBranchGitEnvironmentAsync, resetUncommittedChanges, } from '../../utils/git-branch-manager.js';
 import { createBranchPullRequest, } from '../code-implementation/branch-pr-creator.js';
 import { getGitHubConfig } from '../../api/github.js';
+import { gitPush } from '../../utils/git-push.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { createAutonomousSystemPrompt, createAutonomousUserPrompt, } from './prompts.js';
 /**
@@ -35,59 +36,6 @@ async function* prompt(userPrompt) {
     yield userMessage(userPrompt);
     await new Promise((res) => setTimeout(res, 10000));
 }
-/**
- * Push branch to remote repository
- */
-async function pushToRemote(branchName, verbose) {
-    try {
-        const { execSync } = await import('child_process');
-        if (verbose) {
-            logInfo(`📤 Pushing branch ${branchName} to remote...`);
-        }
-        try {
-            execSync(`git push -u origin ${branchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-            return { success: true };
-        }
-        catch {
-            try {
-                execSync(`git push origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                return { success: true };
-            }
-            catch {
-                if (verbose) {
-                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-                }
-                try {
-                    execSync(`git push --force-with-lease origin ${branchName}`, {
-                        encoding: 'utf-8',
-                        stdio: verbose ? 'inherit' : 'pipe',
-                    });
-                    return { success: true };
-                }
-                catch (forceError) {
-                    return {
-                        success: false,
-                        error: forceError instanceof Error
-                            ? forceError.message
-                            : String(forceError),
-                    };
-                }
-            }
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
 /**
  * Run a single autonomous iteration using Claude Code SDK
  */
@@ -265,14 +213,19 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
             logInfo(`⏱️  Iteration ${totalIterations} took ${(iterationDuration / 1000).toFixed(0)}s`);
             if (iterationResult.success) {
                 logInfo(`✅ Iteration ${totalIterations}: ${iterationResult.summary || 'completed'}`);
-                // Push to remote
-                const pushResult = await pushToRemote(devBranchName, verbose);
+                // Get GitHub config for push authentication and PR creation
+                const githubConfig = await getGitHubConfig(featureId, verbose);
+                // Push to remote with authentication
+                const pushResult = gitPush({
+                    branchName: devBranchName,
+                    token: githubConfig.configured ? githubConfig.token : undefined,
+                    verbose,
+                });
                 if (!pushResult.success && verbose) {
                     logError(`⚠️  Failed to push: ${pushResult.error}`);
                 }
                 // Create PR after first successful iteration
                 if (!prUrl) {
-                    const githubConfig = await getGitHubConfig(featureId, verbose);
                     if (githubConfig.configured &&
                         githubConfig.token &&
                         githubConfig.owner &&

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