edsger 0.41.1 → 0.41.3

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/functional-testing/analyzer.js

@@ -326,9 +326,7 @@ async function saveTestResults(featureId, testStatus, structuredTestResult, last
     }
     return testReportResult;
 }
-export const runFunctionalTesting = async (options, config, checklistContext
-// eslint-disable-next-line complexity -- orchestration function coordinating functional test execution and result processing
-) => {
+export const runFunctionalTesting = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting functional testing for feature ID: ${featureId}`);

package/dist/phases/growth-analysis/index.js

@@ -49,9 +49,7 @@ contentSuggestions) {
     }
     return plans;
 }
-export const analyseGrowth = async (options, config
-// eslint-disable-next-line complexity -- orchestration function with context assembly, agent execution, and result processing
-) => {
+export const analyseGrowth = async (options, config) => {
     const { productId, verbose, guidance, analysisId } = options;
     if (verbose) {
         logInfo(`Starting growth analysis for product ID: ${productId}`);

package/dist/phases/pr-execution/file-assigner.js

@@ -86,22 +86,30 @@ async function callLLMForAssignment(prompt, verbose) {
             message: { role: 'user', content: prompt },
         };
     }
-    for await (const message of query({
-        prompt: userMessage(),
-        options: {
-            model: DEFAULT_MODEL,
-            maxTurns: 1,
-            permissionMode: 'bypassPermissions',
-        },
-    })) {
-        if (message.type === 'assistant' && message.message?.content) {
-            for (const item of message.message.content) {
-                if (item.type === 'text') {
-                    responseText += `${item.text}\n`;
+    try {
+        for await (const message of query({
+            prompt: userMessage(),
+            options: {
+                model: DEFAULT_MODEL,
+                maxTurns: 5,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const item of message.message.content) {
+                    if (item.type === 'text') {
+                        responseText += `${item.text}\n`;
+                    }
                 }
             }
         }
     }
+    catch (error) {
+        if (verbose) {
+            logError(`LLM query failed during file assignment: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return null;
+    }
     const parsed = extractJsonFromResponse(responseText, '"assignments"');
     if (!parsed || !Array.isArray(parsed.assignments)) {
         if (verbose) {

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

@@ -2,7 +2,7 @@ import { query } from '@anthropic-ai/claude-agent-sdk';
 import { execSync } from 'child_process';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
-import { getPullRequests } from '../../services/pull-requests.js';
+import { getPullRequests, } from '../../services/pull-requests.js';
 import { getCurrentBranch, returnToMainBranch, } from '../../utils/git-branch-manager.js';
 import { logDebug, logError, logInfo } from '../../utils/logger.js';
 import { fetchPRExecutionContext } from './context.js';
@@ -98,6 +98,18 @@ export const executeFeaturePRs = async (options, config) => {
             }
         }
         // ======================================
+        // Filter to only the next eligible PR
+        // ======================================
+        // Only process the first pending PR whose predecessor is merged/closed.
+        // Already-executed PRs (branch_created, pr_opened, etc.) are included for sync.
+        activePullRequests = filterToEligiblePRs(activePullRequests, verbose);
+        if (activePullRequests.length === 0) {
+            if (verbose) {
+                logInfo('No eligible PRs to process — waiting for current PR to be merged or closed.');
+            }
+            return buildNoChangeResult(featureId, context.pullRequests.length);
+        }
+        // ======================================
         // Agent: Create/Update branches
         // ======================================
         if (verbose) {
@@ -285,6 +297,52 @@ export const executeFeaturePRs = async (options, config) => {
         return buildExecutionErrorResult(featureId, errorMessage);
     }
 };
+/**
+ * Filter PRs to only include the next eligible pending PR.
+ *
+ * - Already-executed PRs (branch_created, pr_opened, in_review, approved) are
+ *   kept for incremental sync.
+ * - Merged/closed PRs are excluded (no branch work needed).
+ * - Only the first pending PR is included, and only if the PR immediately
+ *   before it (by sequence) is merged or closed (or it's the first PR).
+ * - All other pending PRs are blocked until the current one completes.
+ */
+function filterToEligiblePRs(pullRequests, verbose) {
+    const sorted = [...pullRequests].sort((a, b) => a.sequence - b.sequence);
+    const eligible = [];
+    let foundPendingToProcess = false;
+    let blockedCount = 0;
+    for (let i = 0; i < sorted.length; i++) {
+        const pr = sorted[i];
+        if (pr.status === 'merged' || pr.status === 'closed') {
+            // Done — no branch work needed
+            continue;
+        }
+        if (pr.status !== 'pending') {
+            // Already executed but not done — include for incremental sync
+            eligible.push(pr);
+            continue;
+        }
+        // PR is pending
+        if (foundPendingToProcess) {
+            blockedCount++;
+            continue;
+        }
+        // Check if the previous PR (by sequence) is merged or closed
+        const prevPR = i > 0 ? sorted[i - 1] : null;
+        if (!prevPR || prevPR.status === 'merged' || prevPR.status === 'closed') {
+            eligible.push(pr);
+        }
+        else {
+            blockedCount++;
+        }
+        foundPendingToProcess = true;
+    }
+    if (blockedCount > 0 && verbose) {
+        logInfo(`⏳ ${blockedCount} pending PR(s) waiting for previous PR to be merged or closed`);
+    }
+    return eligible;
+}
 /**
  * Execute an agent query for branch creation/update
  */

package/dist/phases/pr-resolve/prompts.js

@@ -73,8 +73,9 @@ export function createResolveUserPrompt(unresolvedThreads) {
     let commentIndex = 0;
     for (const thread of unresolvedThreads) {
         const firstComment = thread.comments.nodes[0];
-        if (!firstComment)
+        if (!firstComment) {
             continue;
+        }
         commentIndex++;
         const commentId = `comment_${commentIndex}`;
         commentIdToThreadId.set(commentId, thread.id);

package/dist/phases/pr-resolve/workspace.d.ts

@@ -18,7 +18,7 @@ export declare function prepareWorkspace(owner: string, repo: string, headRef: s
 /**
  * Push changes from workspace back to remote.
  */
-export declare function pushChanges(repoPath: string, headRef: string, token: string, verbose?: boolean): boolean;
+export declare function pushChanges(repoPath: string, headRef: string, token: string, _verbose?: boolean): boolean;
 /**
  * Check if there are uncommitted changes in the workspace.
  */

package/dist/phases/pr-resolve/workspace.js

@@ -98,7 +98,7 @@ export function prepareWorkspace(owner, repo, headRef, prNumber, token, verbose)
 /**
  * Push changes from workspace back to remote.
  */
-export function pushChanges(repoPath, headRef, token, verbose) {
+export function pushChanges(repoPath, headRef, token, _verbose) {
     const gitCredentialArgs = buildCredentialArgs(token);
     try {
         execFileSync('git', [...gitCredentialArgs, 'push', 'origin', headRef], {

package/dist/phases/pr-review/__tests__/review-comments.test.js

@@ -17,11 +17,13 @@ function mapCommentsToReviewPayload(agentComments, files) {
     const result = [];
     for (const comment of agentComments) {
         const lineToPosition = fileLineToPosition.get(comment.file);
-        if (!lineToPosition)
+        if (!lineToPosition) {
             continue;
+        }
         const positionResult = findClosestPosition(comment.line, lineToPosition);
-        if (!positionResult)
+        if (!positionResult) {
             continue;
+        }
         let body = comment.comment;
         if (positionResult.actualLine !== comment.line) {
             body = `**Note**: Comment originally for line ${comment.line}, adjusted to line ${positionResult.actualLine} (nearest line in diff).\n\n${body}`;

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

@@ -14,9 +14,7 @@ import { createStandaloneReviewSystemPrompt, createStandaloneReviewUserPrompt, }
 /**
  * Review a standalone PR and post comments to GitHub.
  */
-export async function reviewStandalonePR(options
-// eslint-disable-next-line complexity
-) {
+export async function reviewStandalonePR(options) {
     const { pullRequestUrl, githubToken, verbose, prId } = options;
     logInfo(`Starting standalone PR review: ${pullRequestUrl}`);
     try {

package/dist/phases/pr-shared/agent-utils.js

@@ -24,7 +24,6 @@ export async function* createPromptGenerator(prompt) {
 /**
  * Extract text content from assistant message content array.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function extractTextFromContent(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 content, verbose) {

package/dist/phases/pr-shared/context.d.ts

@@ -3,8 +3,8 @@
  * Reuses GitHub API utilities from code-review/context.ts without feature dependencies.
  */
 import { type PRCommit, type PRData, type PRFile } from '../code-review/context.js';
-export { parsePullRequestUrl } from '../code-review/context.js';
 export type { PRCommit, PRData, PRFile } from '../code-review/context.js';
+export { parsePullRequestUrl } from '../code-review/context.js';
 export interface StandalonePRContext {
     pullRequestUrl: string;
     pullRequestNumber: number;

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

@@ -27,9 +27,7 @@ async function* prompt(analysisPrompt) {
  * then uses AI to produce a PR split plan saved to the database.
  * Human review is expected before running the pr-execution phase.
  */
-export const splitFeatureIntoPRs = async (options, config
-// eslint-disable-next-line complexity -- orchestration function with context fetching, agent execution, and result processing
-) => {
+export const splitFeatureIntoPRs = async (options, config) => {
     const { featureId, verbose, replaceExisting } = options;
     if (verbose) {
         logInfo(`Starting PR splitting for feature ID: ${featureId}`);

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