next-issue 1.0.2 → 1.0.3

package/README.md

@@ -17,7 +17,8 @@ For each open issue, oldest first:
    resume too. An issue that GitHub lists as blocked by an open issue waits,
    because its blocker closes only when the pull request of the blocker merges.
    An issue with saved state under `.next-issue/` resumes instead, whatever its
-   other labels and blockers.
+   other labels and blockers. Such an issue joins the list also when it is
+   closed, if its pull request is merged.
 2. Add `status:in-progress` to the issue.
 3. Fetch the remote, fast-forward the local copy of the default branch when
    that is safe, then add a git worktree at `../<repo>-issue-<n>` on the
@@ -66,8 +67,13 @@ For each open issue, oldest first:
     the check budget, and the harness force-pushes the fix, reopens the issue
     and opens a new pull request that goes to step 6 again, with fresh review
     rounds. The next issue waits for this, and a second ctrl-c stops only after
-    it. The worktree, the local branch and the state file go away. Without
-    `--merge`, the remote branch stays. A problem that the reviewer leaves out
+    it. The worktree, the local branch and the state file go away. A resume
+    whose pull request is already merged goes straight to the wait for the
+    checks on the base branch, and opens no new pull request. A resume that
+    stopped inside the fix of the base branch carries on with that fix, and
+    uses no more of the check budget. Without `--merge`, the remote branch
+    stays, and a resume whose pull request a person merged sets
+    `status:done` and waits for no check. A problem that the reviewer leaves out
     of the findings thus gets an approval: only the findings count.
 11. With an open finding, run the fixer agent and go to step 6 again. The
     budget is `maxReviewRounds`. A fixer that holds every finding to be wrong

package/dist/cli.mjs

@@ -5,11 +5,11 @@ import { parseArgs, USAGE } from "./args.mjs";
 import { loadConfig, writeDefaultConfig } from "./config.mjs";
 import { setCommandObserver, setDefaultTimeout } from "./exec.mjs";
 import { detectRepo, ensureIgnored, repoRoot } from "./git.mjs";
-import { defaultBranch, openIssues } from "./github.mjs";
+import { defaultBranch } from "./github.mjs";
 import { listenForInterrupts } from "./interrupt.mjs";
 import { exitCode, runIssues } from "./loop.mjs";
 import { message, pruneRuns, Recorder } from "./observe.mjs";
-import { PORTS, processIssue } from "./pipeline.mjs";
+import { pendingIssues, PORTS, processIssue } from "./pipeline.mjs";
 import { STATE_DIR } from "./state.mjs";
 import { formatSummary } from "./summary.mjs";
 import { packageVersion } from "./version.mjs";
@@ -79,7 +79,7 @@ async function handle(args, config, repo, recorder) {
         base,
         log: recorder.logFile,
     }, "quiet");
-    const issues = await openIssues(repo, config.issueLimit);
+    const issues = await pendingIssues(context);
     recorder.event("issues", { open: issues.length }, "quiet");
     const { reports, stoppedAt } = await runIssues(args, {
         issues,

package/dist/github.mjs

@@ -34,6 +34,16 @@ export async function defaultBranch(repo) {
     });
     return JSON.parse(raw).defaultBranchRef.name;
 }
+const ISSUE_FIELDS = "number,title,body,createdAt,labels";
+function toIssue(item) {
+    return {
+        number: item.number,
+        title: item.title,
+        body: item.body ?? "",
+        createdAt: item.createdAt,
+        labels: item.labels.map((label) => label.name),
+    };
+}
 export async function openIssues(repo, limit) {
     const raw = await gh(repo, [
         "issue",
@@ -45,18 +55,14 @@ export async function openIssues(repo, limit) {
         "--limit",
         String(limit),
         "--json",
-        "number,title,body,createdAt,labels",
+        ISSUE_FIELDS,
     ]);
     const parsed = JSON.parse(raw);
-    return parsed
-        .map((item) => ({
-        number: item.number,
-        title: item.title,
-        body: item.body ?? "",
-        createdAt: item.createdAt,
-        labels: item.labels.map((label) => label.name),
-    }))
-        .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return parsed.map(toIssue).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+export async function viewIssue(repo, issue) {
+    const raw = await gh(repo, ["issue", "view", String(issue), "--json", ISSUE_FIELDS]);
+    return toIssue(JSON.parse(raw));
 }
 export async function issueComments(repo, issue) {
     const raw = await gh(repo, ["issue", "view", String(issue), "--json", "comments"]);
@@ -297,6 +303,9 @@ export async function mergePr(repo, pr) {
     const result = await run("gh", ["pr", "merge", String(pr), "--squash", "--delete-branch", "--repo", slug(repo)], { cwd: repo.root });
     return result.code === 0;
 }
+export async function prMerged(repo, pr) {
+    return (await gh(repo, ["pr", "view", String(pr), "--json", "state", "--jq", ".state"])).trim() === "MERGED";
+}
 export async function mergeCommit(repo, pr, options, clock = REAL_CLOCK) {
     const deadline = clock.now() + options.timeoutMs;
     for (;;) {

package/dist/pipeline.mjs

@@ -2,11 +2,11 @@ import { CODING, REVIEWING, runAgent } from "./agents.mjs";
 import { managedLabels } from "./config.mjs";
 import { run } from "./exec.mjs";
 import { addWorktree, branchName, commitAll, deleteBranch, diff, discardChanges, hasWorktree, isDirty, push, removeWorktree, resetToBase, revision, worktreePath, } from "./git.mjs";
-import { commentOnPr, createPr, failedBaseLogs, failedCheckLogs, findPr, issueComments, markPrReady, mergeCommit, mergePr, openBlockers, reopenIssue, setLabel, waitForBaseChecks, waitForChecks, } from "./github.mjs";
+import { commentOnPr, createPr, failedBaseLogs, failedCheckLogs, findPr, issueComments, markPrReady, mergeCommit, mergePr, openBlockers, openIssues, prMerged, reopenIssue, setLabel, viewIssue, waitForBaseChecks, waitForChecks, } from "./github.mjs";
 import { message } from "./observe.mjs";
 import { capDiff, fixPrompt, hookPrompt, implementPrompt, parseCommitSubject, parseUnrelated, reviewPrompt, } from "./prompts.mjs";
 import { detectSetupCommand } from "./setup.mjs";
-import { dropState, readState, resetState, writeState, } from "./state.mjs";
+import { dropState, readState, resetState, savedIssues, writeState, } from "./state.mjs";
 import { blockingFindings, fingerprint, formatFindings, formatVerdict, openFindings, readVerdict, VERDICT_SCHEMA, } from "./verdict.mjs";
 export const PORTS = {
     addWorktree,
@@ -27,6 +27,8 @@ export const PORTS = {
     mergeCommit,
     mergePr,
     openBlockers,
+    openIssues,
+    prMerged,
     push,
     removeWorktree,
     reopenIssue,
@@ -35,6 +37,7 @@ export const PORTS = {
     runAgent,
     runSetup: async (command, cwd, timeoutMs) => run("bash", ["-lc", command], { cwd, timeoutMs }),
     setLabel,
+    viewIssue,
     waitForBaseChecks,
     waitForChecks,
 };
@@ -55,6 +58,21 @@ export function skipReason(issue, config, resuming) {
     }
     return undefined;
 }
+export async function pendingIssues(context) {
+    const { repo, config, ports } = context;
+    const issues = await ports.openIssues(repo, config.issueLimit);
+    const listed = new Set(issues.map((issue) => issue.number));
+    for (const number of await savedIssues(repo)) {
+        if (listed.has(number)) {
+            continue;
+        }
+        const saved = await readState(repo, number).catch(() => undefined);
+        if (saved?.pr !== undefined && (await ports.prMerged(repo, saved.pr))) {
+            issues.push(await ports.viewIssue(repo, number));
+        }
+    }
+    return issues.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
 export async function processIssue(context, issue) {
     const started = Date.now();
     const log = context.recorder.scope({ issue: issue.number });
@@ -182,9 +200,29 @@ async function work(context, issue, log, state) {
     if (context.stopAfterRound()) {
         return stop(job);
     }
-    await log.step("push", { branch }, () => ports.push(worktree, config.remote, branch));
-    state.phase = "review";
-    await openPr(job);
+    if (state.baseFix !== undefined) {
+        job.mainBroken = true;
+        const fixed = await fixBase(job);
+        if (fixed.done) {
+            return fixed.report;
+        }
+    }
+    else if (state.phase === "review" && state.pr !== undefined && (await ports.prMerged(repo, state.pr))) {
+        log.event("pull-request.merged", { pr: state.pr }, "quiet");
+        if (!context.merge) {
+            await setStatus(context, issue.number, state.pr, config.labels.done);
+            return finish(job, "done");
+        }
+        const landed = await afterMerge(job);
+        if (landed.done) {
+            return landed.report;
+        }
+    }
+    else {
+        await log.step("push", { branch }, () => ports.push(worktree, config.remote, branch));
+        state.phase = "review";
+        await openPr(job);
+    }
     for (;;) {
         if (context.stopAfterRound()) {
             return stop(job);
@@ -320,13 +358,7 @@ async function reviewRound(job) {
                 await escalate(job, "The merge of the pull request failed.");
                 return { done: true, report: await finish(job, "needs-human", "merge failed") };
             }
-            const watched = await watchBase(job);
-            if (watched.done) {
-                return { done: true, report: watched.report };
-            }
-            if (watched.fixed) {
-                return { done: false };
-            }
+            return afterMerge(job);
         }
         await setStatus(context, issue.number, pr, config.labels.done);
         return { done: true, report: await finish(job, "done") };
@@ -356,8 +388,20 @@ async function reviewRound(job) {
     }
     return { done: false };
 }
+async function afterMerge(job) {
+    const { context, issue, state } = job;
+    const watched = await watchBase(job);
+    if (watched.done) {
+        return { done: true, report: watched.report };
+    }
+    if (watched.fixed) {
+        return { done: false };
+    }
+    await setStatus(context, issue.number, state.pr, context.config.labels.done);
+    return { done: true, report: await finish(job, "done") };
+}
 async function watchBase(job) {
-    const { context, issue, log, state, worktree } = job;
+    const { context, log, state, worktree } = job;
     const { repo, config, ports } = context;
     const sha = await ports.mergeCommit(repo, state.pr, {
         intervalSeconds: config.checkIntervalSeconds,
@@ -385,12 +429,19 @@ async function watchBase(job) {
         await escalate(job, `The checks on main failed and the limit of ${config.maxCiFixes} check fixes was reached.`);
         return { done: true, report: await finish(job, "needs-human", "check budget") };
     }
+    await ports.resetToBase(worktree, context.base, config.remote);
     state.ciFixes += 1;
+    state.baseFix = { sha, head: await ports.revision(worktree) };
     await writeState(repo, state);
-    await ports.resetToBase(worktree, context.base, config.remote);
+    return fixBase(job);
+}
+async function fixBase(job) {
+    const { context, issue, log, state } = job;
+    const { repo, config, ports } = context;
+    const { sha, head } = state.baseFix;
     const logs = await ports.failedBaseLogs(repo, sha, config.logMaxChars);
     log.event("main-checks.logs", { chars: logs.length });
-    const fix = await fixRound(job, "The checks on main failed after the merge.", logs, [], "checks", true);
+    const fix = await fixRound(job, "The checks on main failed after the merge.", logs, [], "checks", true, head);
     if (!fix.committed) {
         const note = fix.unrelated;
         await escalate(job, note === undefined
@@ -404,6 +455,7 @@ async function watchBase(job) {
     await ports.reopenIssue(repo, issue.number);
     state.reviewRounds = 0;
     state.reviewLog = [];
+    state.baseFix = undefined;
     await openPr(job);
     return { done: false, fixed: true };
 }
@@ -443,10 +495,10 @@ async function finish(job, outcome, reason) {
         ...(job.mainBroken && outcome !== "done" ? { halt: true } : {}),
     };
 }
-async function fixRound(job, reason, detail, earlier, kind, force = false) {
+async function fixRound(job, reason, detail, earlier, kind, force = false, from) {
     const { context, issue, log, worktree, branch } = job;
     const { ports } = context;
-    const before = await ports.revision(worktree);
+    const before = from ?? (await ports.revision(worktree));
     const result = await log.step("fix", { reason }, () => ports.runAgent(log, {
         name: "fixer",
         cwd: worktree,

package/dist/state.mjs

@@ -1,4 +1,4 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 export const STATE_DIR = ".next-issue";
 function dir(repo) {
@@ -26,6 +26,22 @@ export async function readState(repo, issue) {
         throw new Error(`the state file ${path} is not valid JSON`);
     }
 }
+export async function savedIssues(repo) {
+    let names;
+    try {
+        names = await readdir(dir(repo));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    return names.flatMap((name) => {
+        const match = /^(\d+)\.json$/.exec(name);
+        return match === null ? [] : [Number(match[1])];
+    });
+}
 export function resetState(state) {
     return { ...state, ciFixes: 0, commitFixes: 0, reviewRounds: 0, reviewLog: [] };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-issue",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Autonomous issue harness driven by the Claude Agent SDK",
   "keywords": [
     "github",