edsger 0.30.0 → 0.30.2

package/dist/phases/feature-analysis-verification/verifier.js

@@ -0,0 +1,147 @@
+/**
+ * Checklist verification agent for feature analysis
+ * This agent independently reviews checklist compliance to ensure objectivity
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { createChecklistVerificationPrompt, createChecklistVerificationSystemPrompt, } from './prompts.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(verificationPrompt) {
+    yield userMessage(verificationPrompt);
+}
+/**
+ * Verify checklist compliance using an independent AI agent
+ * This agent acts as a "challenger" to validate the claims made by the analysis agent
+ */
+export async function verifyChecklistCompliance(options, config) {
+    const { checklistContext, analysisContext, createdUserStories, createdTestCases, verbose, } = options;
+    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
+    if (verbose) {
+        logInfo('🔍 Starting checklist verification...');
+        logInfo(`   Verifying ${totalChecklistItems} checklist items`);
+    }
+    try {
+        const systemPrompt = createChecklistVerificationSystemPrompt(config);
+        const verificationPrompt = createChecklistVerificationPrompt({
+            checklistContext,
+            analysisContext,
+            createdUserStories,
+            createdTestCases,
+        });
+        let lastAssistantResponse = '';
+        let verificationResult = null;
+        if (verbose) {
+            logInfo('🤖 Starting verification agent query...');
+        }
+        // Use Claude Code SDK for verification
+        for await (const message of query({
+            prompt: prompt(verificationPrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 100,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`   Received message type: ${message.type}`);
+            }
+            // Capture assistant responses
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        lastAssistantResponse += content.text + '\n';
+                        if (verbose) {
+                            console.log(`\n🔍 ${content.text}`);
+                        }
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('\n✅ Verification completed, parsing results...');
+                    try {
+                        const responseText = message.result || lastAssistantResponse;
+                        // Try to extract JSON from markdown code block
+                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        let jsonResult = null;
+                        if (jsonBlockMatch) {
+                            jsonResult = JSON.parse(jsonBlockMatch[1]);
+                        }
+                        else {
+                            jsonResult = JSON.parse(responseText);
+                        }
+                        if (jsonResult && jsonResult.verification) {
+                            verificationResult = jsonResult.verification;
+                        }
+                        else {
+                            throw new Error('Invalid verification JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse verification result: ${error}`);
+                        // Return default "uncertain" result
+                        verificationResult = createUncertainVerificationResult(checklistContext, 'Failed to parse verification response');
+                    }
+                }
+                else {
+                    logError(`\n⚠️ Verification incomplete: ${message.subtype}`);
+                    verificationResult = createUncertainVerificationResult(checklistContext, `Verification incomplete: ${message.subtype}`);
+                }
+            }
+        }
+        if (!verificationResult) {
+            verificationResult = createUncertainVerificationResult(checklistContext, 'No verification result received');
+        }
+        if (verbose) {
+            logInfo('\n📊 Verification Summary:');
+            logInfo(`   Total items: ${verificationResult.total_items}`);
+            logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
+            logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
+            logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
+            logInfo(`   Summary: ${verificationResult.summary}`);
+            if (verificationResult.rejected_count > 0) {
+                logInfo('\n❌ Rejected items:');
+                verificationResult.item_verifications
+                    .filter((v) => v.verification_status === 'rejected')
+                    .forEach((v) => {
+                    logInfo(`   - ${v.checklist_item_id}`);
+                    logInfo(`     Reason: ${v.verification_reason}`);
+                });
+            }
+        }
+        return verificationResult;
+    }
+    catch (error) {
+        logError(`Checklist verification failed: ${error instanceof Error ? error.message : String(error)}`);
+        return createUncertainVerificationResult(checklistContext, `Verification error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Create a default "uncertain" verification result when verification fails
+ */
+function createUncertainVerificationResult(checklistContext, reason) {
+    // Get all checklist items
+    const allItems = checklistContext.checklists.flatMap((checklist) => checklist.items.map((item) => ({
+        checklist_item_id: item.id,
+    })));
+    return {
+        all_verified: false,
+        total_items: allItems.length,
+        confirmed_count: 0,
+        rejected_count: 0,
+        uncertain_count: allItems.length,
+        item_verifications: allItems.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_satisfied: false,
+            verification_status: 'uncertain',
+            verification_reason: reason,
+        })),
+        summary: `Verification could not be completed: ${reason}`,
+    };
+}

package/dist/phases/pr-execution/index.js

@@ -108,6 +108,7 @@ export const executeFeaturePRs = async (options, config) => {
             repo: context.githubConfig.repo,
             forkInfo: context.forkInfo,
             verbose,
+            token: context.githubConfig.token,
         };
         const executionSummary = {
             branchesCreated: 0,

package/dist/phases/pr-execution/pr-executor.d.ts

@@ -8,6 +8,7 @@ export interface PRExecutionConfig {
     repo: string;
     forkInfo: RepoForkInfo;
     verbose?: boolean;
+    token?: string;
 }
 export interface PRBranchResult {
     branchName: string;
@@ -19,7 +20,7 @@ export interface PRBranchResult {
 /**
  * Push a branch to remote with force-with-lease fallback
  */
-export declare function pushBranch(branchName: string, verbose?: boolean): void;
+export declare function pushBranch(branchName: string, verbose?: boolean, token?: string): void;
 /**
  * Get the HEAD SHA of a local branch
  */

package/dist/phases/pr-execution/pr-executor.js

@@ -2,53 +2,24 @@
  * PR Executor for pushing branches to remote and generating compare URLs
  * Handles fork-aware URL construction for manual PR creation
  */
-import { execSync } from 'child_process';
 import { logInfo } from '../../utils/logger.js';
 import { updatePullRequest } from '../../services/pull-requests.js';
+import { gitPush } from '../../utils/git-push.js';
+import { execFileSync } from 'child_process';
 /**
  * Push a branch to remote with force-with-lease fallback
  */
-export function pushBranch(branchName, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`📤 Pushing branch ${branchName} to remote...`);
-        }
-        try {
-            execSync(`git push -u origin ${branchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-        }
-        catch {
-            try {
-                execSync(`git push origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-            }
-            catch {
-                if (verbose) {
-                    logInfo(`⚠️ Push rejected, attempting force push with lease...`);
-                }
-                execSync(`git push --force-with-lease origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                if (verbose) {
-                    logInfo(`✅ Successfully force pushed ${branchName}`);
-                }
-            }
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to push branch ${branchName}: ${error instanceof Error ? error.message : String(error)}`);
+export function pushBranch(branchName, verbose, token) {
+    const result = gitPush({ branchName, token, verbose });
+    if (!result.success) {
+        throw new Error(`Failed to push branch ${branchName}: ${result.error}`);
     }
 }
 /**
  * Get the HEAD SHA of a local branch
  */
 export function getLocalBranchSha(branchName) {
-    return execSync(`git rev-parse ${branchName}`, {
+    return execFileSync('git', ['rev-parse', branchName], {
         encoding: 'utf-8',
     }).trim();
 }
@@ -68,10 +39,10 @@ export function buildCompareUrl(forkInfo, owner, repo, branchName, base = 'main'
  * Push a branch and build the compare URL
  */
 export function pushBranchAndBuildUrl(config, branchName) {
-    const { owner, repo, forkInfo, verbose } = config;
+    const { owner, repo, forkInfo, verbose, token } = config;
     const headSha = getLocalBranchSha(branchName);
     try {
-        pushBranch(branchName, verbose);
+        pushBranch(branchName, verbose, token);
         const compareUrl = buildCompareUrl(forkInfo, owner, repo, branchName);
         if (verbose) {
             logInfo(`🔗 Compare URL: ${compareUrl}`);

package/dist/phases/pull-request/creator.js

@@ -4,6 +4,7 @@
  */
 import { Octokit } from '@octokit/rest';
 import { execSync } from 'child_process';
+import { gitPush } from '../../utils/git-push.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
 const PR_TITLE_PREFIX = 'feat: ';
@@ -115,39 +116,6 @@ const switchToBranch = (branch, verbose) => {
         throw new Error(`Failed to switch to branch ${branch}: ${error}`);
     }
 };
-/**
- * Push current branch to remote
- * Falls back to force-with-lease if normal push fails (e.g., after rebase)
- */
-const pushBranch = (branch, verbose) => {
-    try {
-        if (verbose) {
-            console.log(`📤 Pushing branch ${branch} to remote...`);
-        }
-        execSync(`git push -u origin ${branch}`, { encoding: 'utf-8' });
-        if (verbose) {
-            console.log(`✅ Branch pushed successfully`);
-        }
-    }
-    catch (error) {
-        // If push fails (likely non-fast-forward after rebase),
-        // use force-with-lease for safer force push
-        if (verbose) {
-            console.log(`⚠️  Push rejected, attempting force push with lease...`);
-        }
-        try {
-            execSync(`git push --force-with-lease origin ${branch}`, {
-                encoding: 'utf-8',
-            });
-            if (verbose) {
-                console.log(`✅ Successfully force pushed ${branch}`);
-            }
-        }
-        catch (forceError) {
-            throw new Error(`Failed to push branch: ${forceError}`);
-        }
-    }
-};
 /**
  * Switch to main branch
  */
@@ -276,7 +244,10 @@ export async function createPullRequest(config, feature) {
             }
             try {
                 // Push current branch to remote first
-                pushBranch(currentBranch, verbose);
+                const pushResult = gitPush({ branchName: currentBranch, token: githubToken, verbose });
+                if (!pushResult.success) {
+                    throw new Error(`Failed to push branch: ${pushResult.error}`);
+                }
                 // Get the base branch (main) SHA to create feat/ branch from
                 const { data: baseBranchData } = await octokit.repos.getBranch({
                     owner,
@@ -306,7 +277,10 @@ export async function createPullRequest(config, feature) {
         }
         else {
             // If not a dev/ branch, push it normally
-            pushBranch(currentBranch, verbose);
+            const pushResult = gitPush({ branchName: currentBranch, token: githubToken, verbose });
+            if (!pushResult.success) {
+                throw new Error(`Failed to push branch: ${pushResult.error}`);
+            }
         }
         // Generate PR title and body
         const title = generatePRTitle(feature.name);

package/dist/phases/technical-design/analyzer-helpers.d.ts

@@ -0,0 +1,25 @@
+import { type ChecklistVerificationResult } from '../technical-design-verification/agent.js';
+export interface TechnicalDesignResult {
+    featureId: string;
+    technicalDesign: string | null;
+    status: 'success' | 'error';
+    summary: string;
+    verificationResult?: ChecklistVerificationResult;
+    iterations?: number;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
+}
+/**
+ * Build successful design result
+ */
+export declare function buildDesignResult(featureId: string, technicalDesign: string, summary: string, iterations: number, checklistItemResults?: any[]): TechnicalDesignResult;
+/**
+ * Build verification failure result
+ */
+export declare function buildVerificationFailureResult(featureId: string, technicalDesign: string, verificationResult: ChecklistVerificationResult, iterations: number): TechnicalDesignResult;
+/**
+ * Build error result when no design was generated
+ */
+export declare function buildNoResultsError(featureId: string): TechnicalDesignResult;

package/dist/phases/technical-design/analyzer-helpers.js

@@ -0,0 +1,39 @@
+/**
+ * Build successful design result
+ */
+export function buildDesignResult(featureId, technicalDesign, summary, iterations, checklistItemResults) {
+    return {
+        featureId,
+        technicalDesign,
+        status: 'success',
+        summary,
+        iterations,
+        data: checklistItemResults
+            ? { checklist_item_results: checklistItemResults }
+            : undefined,
+    };
+}
+/**
+ * Build verification failure result
+ */
+export function buildVerificationFailureResult(featureId, technicalDesign, verificationResult, iterations) {
+    return {
+        featureId,
+        technicalDesign,
+        status: 'error',
+        summary: `Checklist verification failed after ${iterations} iterations: ${verificationResult.summary}`,
+        verificationResult,
+        iterations,
+    };
+}
+/**
+ * Build error result when no design was generated
+ */
+export function buildNoResultsError(featureId) {
+    return {
+        featureId,
+        technicalDesign: null,
+        status: 'error',
+        summary: 'Failed to generate technical design - no valid result received',
+    };
+}

package/dist/phases/technical-design/analyzer.d.ts

@@ -0,0 +1,21 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface TechnicalDesignOptions {
+    featureId: string;
+    verbose?: boolean;
+    maxVerificationIterations?: number;
+}
+export interface TechnicalDesignResult {
+    featureId: string;
+    technicalDesign: string | null;
+    status: 'success' | 'error';
+    summary: string;
+    verificationResult?: any;
+    iterations?: number;
+    savedViaHttp?: boolean;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
+}
+export declare const generateTechnicalDesign: (options: TechnicalDesignOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<TechnicalDesignResult>;