edsger 0.41.2 → 0.42.0

package/.claude/settings.local.json

@@ -1,28 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "Read(//Users/steven/development/edsger/**)",
-      "Bash(npm run build)",
-      "Bash(node:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(ls:*)",
-      "Bash(cat:*)",
-      "Bash(npm run typecheck:*)",
-      "Bash(git diff:*)",
-      "WebSearch",
-      "WebFetch(domain:supabase.com)",
-      "Bash(npm install:*)",
-      "Bash(grep:*)",
-      "Bash(npx supabase gen types typescript --help:*)",
-      "Bash(git -C /Users/steven/development/edsger status)",
-      "Bash(git -C /Users/steven/development/edsger diff)",
-      "Bash(git -C /Users/steven/development/edsger log --oneline -5)",
-      "Bash(git -C /Users/steven/development/edsger add supabase/migrations/20251231000000_drop_unused_views.sql)",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views that are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views\nthat are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
-    ],
-    "deny": [],
-    "ask": []
+      "Bash(npx tsc:*)",
+      "Bash(npm run:*)"
+    ]
   }
 }

package/dist/commands/pr-resolve/index.d.ts

@@ -6,5 +6,6 @@ export interface PRResolveCliOptions {
     prUrl: string;
     prId?: string;
     verbose?: boolean;
+    learn?: boolean;
 }
 export declare function runPRResolve(productId: string, options: PRResolveCliOptions): Promise<void>;

package/dist/commands/pr-resolve/index.js

@@ -26,6 +26,7 @@ export async function runPRResolve(productId, options) {
         repo: githubConfig.repo,
         prId,
         verbose,
+        learn: options.learn,
     });
     if (result.status === 'success') {
         logSuccess(`PR resolve completed: ${result.message}`);

package/dist/commands/workflow/executors/phase-executor.js

@@ -130,9 +130,7 @@ async function validateAndLogChecklists(options, name, checklistContext, feature
     }
 }
 // Higher-order function for phase execution
-export const createPhaseRunner = (phaseConfig) => async (options, config
-// eslint-disable-next-line complexity -- orchestration function with sequential phase setup, execution, and result processing
-) => {
+export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     const { featureId, verbose } = options;
     const { name, execute } = phaseConfig;
     // Track phase duration for logging

package/dist/commands/workflow/phase-orchestrator.js

@@ -36,9 +36,7 @@ const logAndMarkPhaseCompleted = async (result, verbose) => {
  * Orchestrate phase execution based on execution mode
  * Routes to appropriate phase sequence based on mode (only_*, from_*, full_pipeline)
  */
-export const runPipelineByMode = async (options, config, executionMode
-// eslint-disable-next-line complexity -- orchestration function routing many execution modes to phase sequences
-) => {
+export const runPipelineByMode = async (options, config, executionMode) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`🚀 Starting pipeline with mode: ${executionMode} for feature: ${featureId}`);

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
@@ -299,6 +299,7 @@ program
     .description('AI-resolve change requests on a GitHub PR')
     .requiredOption('--pr-url <url>', 'GitHub PR URL')
     .option('--pr-id <id>', 'Pull request record ID in database')
+    .option('--no-learn', 'Skip checklist learning after resolve')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
     try {

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/index.js

@@ -170,9 +170,7 @@ message, lastAssistantResponse, featureId, verbose
     }
     return null;
 }
-export const implementFeatureCode = async (options, config, checklistContext
-// eslint-disable-next-line complexity -- orchestration function coordinating full code implementation lifecycle
-) => {
+export const implementFeatureCode = async (options, config, checklistContext) => {
     const { featureId, verbose, baseBranch = 'main' } = options;
     if (verbose) {
         logInfo(`Starting code implementation for feature ID: ${featureId}`);

package/dist/phases/code-refine/index.js

@@ -41,9 +41,7 @@ export const MAX_REFINE_ITERATIONS = 10;
  * Similar to technical-design, this includes an iterative improvement cycle:
  * refine → verification → improve → re-refine (if needed)
  */
-export const refineCodeFromPRFeedback = async (options, config, checklistContext
-// eslint-disable-next-line complexity -- orchestration function coordinating PR feedback refinement lifecycle
-) => {
+export const refineCodeFromPRFeedback = async (options, config, checklistContext) => {
     const { featureId, githubToken, verbose } = options;
     if (verbose) {
         logInfo(`Starting code refine for feature ID: ${featureId}`);

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

@@ -67,9 +67,7 @@ baseBranchInfo, baseBranchForRebase, originalBaseBranchForRebase, verbose) {
 /**
  * Main code review function
  */
-export const reviewPullRequest = async (options, config, checklistContext
-// eslint-disable-next-line complexity -- orchestration function coordinating full code review lifecycle
-) => {
+export const reviewPullRequest = async (options, config, checklistContext) => {
     const { featureId, githubToken, verbose } = options;
     if (verbose) {
         logInfo(`Starting code review for feature ID: ${featureId}`);

package/dist/phases/code-testing/analyzer.js

@@ -31,9 +31,7 @@ async function* prompt(testingPrompt) {
         setTimeout(res, 10000);
     });
 }
-export const writeCodeTests = async (options, config
-// eslint-disable-next-line complexity -- orchestration function with context fetching, agent execution, and test result processing
-) => {
+export const writeCodeTests = async (options, config) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting code testing phase for feature ID: ${featureId}`);

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

@@ -6,9 +6,7 @@ import { executeAnalysisQuery, parseAnalysisResult } from './agent.js';
 import { prepareAnalysisContext } from './context.js';
 import { buildAnalysisResult, deleteArtifacts, deleteSpecificArtifacts, getAllDraftArtifactIds, resetReadyArtifactsToDraft, saveAnalysisArtifactsAsDraft, updateArtifactsToReady, } from './outcome.js';
 import { createFeatureAnalysisSystemPrompt } from './prompts.js';
-export const analyseFeature = async (options, config, checklistContext
-// eslint-disable-next-line complexity -- orchestration function with context assembly, agent execution, and result processing
-) => {
+export const analyseFeature = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting feature analysis for feature ID: ${featureId}`);

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/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/__tests__/checklist-learner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/phases/pr-resolve/__tests__/checklist-learner.test.js

@@ -0,0 +1,157 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildLearnerPrompt } from '../checklist-learner.js';
+// ── helpers ──────────────────────────────────────────────────
+function makeThread(id, overrides) {
+    return {
+        id,
+        isResolved: false,
+        isOutdated: false,
+        comments: {
+            totalCount: 1,
+            nodes: [
+                {
+                    id: `${id}-c1`,
+                    author: { login: overrides?.author || 'reviewer' },
+                    body: overrides?.body || 'Please fix this',
+                    path: overrides?.path || 'src/index.ts',
+                    line: overrides && 'line' in overrides ? (overrides.line ?? null) : 10,
+                    url: `https://github.com/o/r/pull/1#${id}`,
+                },
+            ],
+        },
+    };
+}
+function makeMap(entries) {
+    return new Map(entries);
+}
+// ── buildLearnerPrompt ──────────────────────────────────────
+describe('buildLearnerPrompt', () => {
+    it('includes addressed comment count in header', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+            { comment_id: 'comment_2', action: 'changed', reply: 'Done' },
+        ];
+        const threads = [makeThread('t1'), makeThread('t2')];
+        const map = makeMap([
+            ['comment_1', 't1'],
+            ['comment_2', 't2'],
+        ]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('2 review comment(s)'));
+    });
+    it('includes reviewer, file path, line, and comment body', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Added null check' },
+        ];
+        const threads = [
+            makeThread('t1', {
+                path: 'src/auth.ts',
+                line: 42,
+                body: 'Missing null check here',
+                author: 'alice',
+            }),
+        ];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('src/auth.ts'));
+        assert.ok(prompt.includes('42'));
+        assert.ok(prompt.includes('@alice'));
+        assert.ok(prompt.includes('Missing null check here'));
+        assert.ok(prompt.includes('Added null check'));
+    });
+    it('includes resolution text for each comment', () => {
+        const comments = [
+            {
+                comment_id: 'comment_1',
+                action: 'changed',
+                reply: 'Refactored to use try/catch',
+            },
+        ];
+        const threads = [makeThread('t1')];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('**Resolution**: Refactored to use try/catch'));
+    });
+    it('includes summary when provided', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        const threads = [makeThread('t1')];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map, 'Improved error handling across 3 files');
+        assert.ok(prompt.includes('## Overall Summary'));
+        assert.ok(prompt.includes('Improved error handling across 3 files'));
+    });
+    it('omits summary section when not provided', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        const threads = [makeThread('t1')];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(!prompt.includes('## Overall Summary'));
+    });
+    it('handles comment with no matching thread gracefully', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        // Empty threads — no match for comment_1
+        const map = makeMap([['comment_1', 'nonexistent']]);
+        const prompt = buildLearnerPrompt(comments, [], map);
+        // Should still include the comment section with resolution
+        assert.ok(prompt.includes('## comment_1'));
+        assert.ok(prompt.includes('**Resolution**: Fixed'));
+        // Should NOT include reviewer info since thread was not found
+        assert.ok(!prompt.includes('**Reviewer**'));
+    });
+    it('handles comment_id not in map gracefully', () => {
+        const comments = [
+            { comment_id: 'comment_99', action: 'changed', reply: 'Fixed' },
+        ];
+        const prompt = buildLearnerPrompt(comments, [], new Map());
+        assert.ok(prompt.includes('## comment_99'));
+        assert.ok(prompt.includes('**Resolution**: Fixed'));
+    });
+    it('omits line when null', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        const threads = [makeThread('t1', { line: null })];
+        const map = makeMap([['comment_1', 't1']]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('**File**: src/index.ts'));
+        assert.ok(!prompt.includes('**Line**'));
+    });
+    it('uses threadById map correctly for multiple comments', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fix A' },
+            { comment_id: 'comment_3', action: 'changed', reply: 'Fix C' },
+        ];
+        const threads = [
+            makeThread('t1', { body: 'Issue A', path: 'a.ts' }),
+            makeThread('t2', { body: 'Issue B', path: 'b.ts' }),
+            makeThread('t3', { body: 'Issue C', path: 'c.ts' }),
+        ];
+        const map = makeMap([
+            ['comment_1', 't1'],
+            ['comment_2', 't2'],
+            ['comment_3', 't3'],
+        ]);
+        const prompt = buildLearnerPrompt(comments, threads, map);
+        assert.ok(prompt.includes('Issue A'));
+        assert.ok(prompt.includes('a.ts'));
+        assert.ok(prompt.includes('Issue C'));
+        assert.ok(prompt.includes('c.ts'));
+        // comment_2 was not in addressedComments, should not appear
+        assert.ok(!prompt.includes('Issue B'));
+    });
+    it('includes instructions section', () => {
+        const comments = [
+            { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+        ];
+        const prompt = buildLearnerPrompt(comments, [makeThread('t1')], makeMap([['comment_1', 't1']]));
+        assert.ok(prompt.includes('## Instructions'));
+        assert.ok(prompt.includes('code_review checklists'));
+    });
+});

package/dist/phases/pr-resolve/__tests__/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/phases/pr-resolve/__tests__/types.test.js

@@ -0,0 +1,43 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { isResolveResult } from '../types.js';
+describe('isResolveResult', () => {
+    it('returns true for valid ResolveResult', () => {
+        assert.ok(isResolveResult({
+            comments: [
+                { comment_id: 'comment_1', action: 'changed', reply: 'Fixed' },
+            ],
+        }));
+    });
+    it('returns true when optional fields are present', () => {
+        assert.ok(isResolveResult({
+            comments: [],
+            files_modified: ['a.ts'],
+            summary: 'Done',
+        }));
+    });
+    it('returns true for empty comments array', () => {
+        assert.ok(isResolveResult({ comments: [] }));
+    });
+    it('returns false for null', () => {
+        assert.ok(!isResolveResult(null));
+    });
+    it('returns false for undefined', () => {
+        assert.ok(!isResolveResult(undefined));
+    });
+    it('returns false for string', () => {
+        assert.ok(!isResolveResult('not an object'));
+    });
+    it('returns false for number', () => {
+        assert.ok(!isResolveResult(42));
+    });
+    it('returns false when comments is missing', () => {
+        assert.ok(!isResolveResult({ files_modified: ['a.ts'] }));
+    });
+    it('returns false when comments is not an array', () => {
+        assert.ok(!isResolveResult({ comments: 'not-array' }));
+    });
+    it('returns false for empty object', () => {
+        assert.ok(!isResolveResult({}));
+    });
+});

package/dist/phases/pr-resolve/checklist-learner.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Checklist Learner — runs after PR resolve to analyse addressed review
+ * comments and create / update code-review checklists so the same issues
+ * don't recur.
+ *
+ * Uses the Claude Agent SDK with the existing checklist MCP tools.
+ * Strictly non-blocking: failures only log a warning.
+ */
+import { type ReviewThread } from '../code-refine-verification/types.js';
+import { type ResolveComment, type ResolveResult } from './types.js';
+export interface ChecklistLearnerInput {
+    productId: string;
+    unresolvedThreads: ReviewThread[];
+    resolveResult: ResolveResult;
+    /** Maps comment_id (e.g. "comment_1") → GraphQL thread ID */
+    commentIdToThreadId: Map<string, string>;
+    verbose?: boolean;
+}
+/**
+ * Build a user prompt from the addressed review comments.
+ * @param addressedComments - pre-filtered list of comments with action === 'changed'
+ */
+export declare function buildLearnerPrompt(addressedComments: ResolveComment[], unresolvedThreads: ReviewThread[], commentIdToThreadId: Map<string, string>, summary?: string): string;
+/**
+ * Analyse addressed review comments and update code-review checklists.
+ * Non-blocking — catches all errors and logs a warning.
+ */
+export declare function learnFromReviewFeedback(input: ChecklistLearnerInput): Promise<void>;