next-issue 1.0.7 → 1.1.0

package/README.md

@@ -9,7 +9,11 @@ npx -y next-issue@latest
 
 ## What it does
 
-For each open issue, oldest first:
+Before each issue, fetch the open issues again and take the oldest one not yet
+seen in this run. An issue seen once in a run, also a skipped or failed one, is
+not tried again in that run. The run ends when no unseen issue is left. When
+the fetch fails, the run ends there, writes the summary of the issues it handled
+and exits with code 1. For each issue:
 
 1. Claim the issue only when it holds the `status:todo` label and holds no
    `status:in-progress` or `status:in-review` label. A `status:done`,
@@ -354,6 +358,7 @@ that a label still holds back stays as it was.
 | `--once` | Stop after the first handled issue |
 | `--max <n>` | Handle at most n issues |
 | `--merge` | Squash-merge the pull request after the approval, delete the remote branch and fix a failure of the checks on the base branch |
+| `--watch` | Keep running, and read the open issues again after each pass |
 | `--reset` | Drop the saved budgets and findings, and keep the rest of the state |
 | `--json` | Print the machine summary instead of the text one |
 | `--verbose` | Show every command and all agent output |
@@ -363,6 +368,33 @@ that a label still holds back stays as it was.
 The exit code is 1 when an issue needs a person or failed, and 0 when it does
 not, so a cron job or a CI step can read the result of the run.
 
+## Watch for new issues
+
+A run without `--watch` ends when no unseen issue is left. With `--watch`, the
+harness then waits, reads the open issues again and runs another pass, so it
+picks up an issue that someone opens during the run, or one whose blocker
+merges. Each pass tries every open issue again, also one that an earlier pass
+skipped.
+
+The waits follow a fixed back-off in minutes: 1, 2, 3, 5, 10, then 10 from then
+on. A pass that handles an issue, with any outcome other than `skipped`, resets
+the back-off to 1 minute. A pass where every issue is skipped does not reset
+it. Each wait prints a line on standard error with the minutes until the next
+pass.
+
+After each pass that handled an issue, the harness prints the summary of that
+pass. The token totals in it cover that pass only. The exit code at the end
+covers all passes. `--max <n>` counts the handled issues across all passes,
+and `--once` is the same as `--max 1`.
+
+The watch stops:
+
+- at the first `Ctrl-C` during a wait, at once;
+- at the first `Ctrl-C` during an issue, after that issue;
+- after a pass that halts the run, for example when the base branch is broken
+  after `--merge`;
+- when the open issues cannot be read.
+
 ## Development
 
 ```bash

package/dist/args.mjs

@@ -6,6 +6,7 @@ export const USAGE = `next-issue [command] [options]
   --once       stop after the first handled issue
   --max <n>    handle at most n issues
   --merge      squash-merge the pull request after the approval
+  --watch      keep running and read the issues again after each pass
   --reset      drop the saved budgets and findings first
   --json       print the machine summary instead of the text one
   --force      replace an existing config file, with init
@@ -22,6 +23,7 @@ export function parseArgs(argv) {
         reset: false,
         force: false,
         merge: false,
+        watch: false,
         level: "normal",
     };
     for (let index = 0; index < argv.length; index += 1) {
@@ -44,6 +46,9 @@ export function parseArgs(argv) {
         else if (arg === "--merge") {
             args.merge = true;
         }
+        else if (arg === "--watch") {
+            args.watch = true;
+        }
         else if (arg === "--reset") {
             args.reset = true;
         }

package/dist/cli.mjs

@@ -7,7 +7,7 @@ import { setCommandObserver, setDefaultTimeout } from "./exec.mjs";
 import { detectRepo, ensureIgnored, repoRoot, WORKTREE_DIR } from "./git.mjs";
 import { defaultBranch } from "./github.mjs";
 import { listenForInterrupts } from "./interrupt.mjs";
-import { exitCode, runIssues } from "./loop.mjs";
+import { exitCode, runIssues, watchIssues } from "./loop.mjs";
 import { message, pruneRuns, Recorder } from "./observe.mjs";
 import { pendingIssues, PORTS, processIssue } from "./pipeline.mjs";
 import { STATE_DIR } from "./state.mjs";
@@ -82,16 +82,34 @@ async function handle(args, config, repo, recorder) {
         base,
         log: recorder.logFile,
     }, "quiet");
-    const issues = await pendingIssues(context);
-    recorder.event("issues", { open: issues.length }, "quiet");
-    const { reports, stoppedAt } = await runIssues(args, {
-        issues,
+    const loop = {
+        issues: async () => {
+            const issues = await pendingIssues(context);
+            recorder.event("issues", { open: issues.length }, "quiet");
+            return issues;
+        },
         process: (issue) => processIssue(context, issue),
         stop: interrupts.afterIssue,
-    });
+    };
+    const print = (summary) => write(process.stdout, args.json ? `${JSON.stringify(summary, null, 2)}\n` : formatSummary(summary));
+    let passStart = recorder.summary();
+    const { reports, stoppedAt, error } = args.watch
+        ? await watchIssues(args, {
+            ...loop,
+            wait: (minutes) => {
+                recorder.event("watch.wait", { minutes }, "quiet");
+                passStart = recorder.summary();
+                return interrupts.sleep(minutes * 60_000);
+            },
+            passEnd: (issues) => print({ ...recorder.summary(passStart), issues }),
+        })
+        : await runIssues(args, loop);
     if (stoppedAt !== undefined) {
         recorder.event("run.stop", { issue: stoppedAt }, "quiet");
     }
+    if (error !== undefined) {
+        recorder.event("issues.fail", { error: message(error) }, "quiet");
+    }
     recorder.event("run.end", {
         done: count(reports, "done"),
         needsHuman: count(reports, "needs-human"),
@@ -102,8 +120,10 @@ async function handle(args, config, repo, recorder) {
     const summary = { ...recorder.summary(), issues: reports };
     const summaryFile = join(repo.root, STATE_DIR, "runs", `${recorder.runId}.summary.json`);
     await writeFile(summaryFile, `${JSON.stringify(summary, null, 2)}\n`);
-    await write(process.stdout, args.json ? `${JSON.stringify(summary, null, 2)}\n` : formatSummary(summary));
-    return exitCode(reports);
+    if (!args.watch) {
+        await print(summary);
+    }
+    return error === undefined ? exitCode(reports) : 1;
 }
 function count(reports, outcome) {
     return reports.filter((report) => report.outcome === outcome).length;

package/dist/interrupt.mjs

@@ -1,9 +1,14 @@
 import { stopChildren } from "./exec.mjs";
 export function listenForInterrupts(say) {
     let presses = 0;
+    let wake;
     const press = () => {
         presses += 1;
-        if (presses === 1) {
+        if (presses === 1 && wake !== undefined) {
+            say("Stopping now.");
+            wake();
+        }
+        else if (presses === 1) {
             say("Stopping after this issue. Press Ctrl-C again to stop after this round.");
         }
         else if (presses === 2) {
@@ -18,5 +23,20 @@ export function listenForInterrupts(say) {
     return {
         afterIssue: () => presses >= 1,
         afterRound: () => presses >= 2,
+        sleep: (ms) => new Promise((resolve) => {
+            if (presses >= 1) {
+                resolve(false);
+                return;
+            }
+            const timer = setTimeout(() => {
+                wake = undefined;
+                resolve(true);
+            }, ms);
+            wake = () => {
+                clearTimeout(timer);
+                wake = undefined;
+                resolve(false);
+            };
+        }),
     };
 }

package/dist/loop.mjs

@@ -1,9 +1,20 @@
+export const BACK_OFF_MINUTES = [1, 2, 3, 5, 10];
 export async function runIssues(args, loop) {
     const reports = [];
-    for (const issue of loop.issues) {
-        if (args.max !== undefined && handled(reports) >= args.max) {
+    const seen = new Set();
+    while (args.max === undefined || handled(reports) < args.max) {
+        let issues;
+        try {
+            issues = await loop.issues();
+        }
+        catch (error) {
+            return { reports, error };
+        }
+        const issue = issues.find((candidate) => !seen.has(candidate.number));
+        if (issue === undefined) {
             break;
         }
+        seen.add(issue.number);
         const report = await loop.process(issue);
         reports.push(report);
         if (loop.stop() || report.halt === true) {
@@ -15,6 +26,30 @@ export async function runIssues(args, loop) {
     }
     return { reports };
 }
+export async function watchIssues(args, watch) {
+    const limit = args.once ? 1 : args.max;
+    const reports = [];
+    let step = 0;
+    for (;;) {
+        const pass = await runIssues({ once: false, max: limit === undefined ? undefined : limit - handled(reports) }, watch);
+        reports.push(...pass.reports);
+        if (handled(pass.reports) > 0) {
+            await watch.passEnd(pass.reports);
+            step = 0;
+        }
+        if (pass.error !== undefined || pass.stoppedAt !== undefined) {
+            return { ...pass, reports };
+        }
+        if ((limit !== undefined && handled(reports) >= limit) || watch.stop()) {
+            return { reports };
+        }
+        const minutes = BACK_OFF_MINUTES[Math.min(step, BACK_OFF_MINUTES.length - 1)];
+        step += 1;
+        if (!(await watch.wait(minutes))) {
+            return { reports };
+        }
+    }
+}
 export function exitCode(reports) {
     return reports.some((report) => report.outcome === "needs-human" || report.outcome === "error") ? 1 : 0;
 }

package/dist/observe.mjs

@@ -13,6 +13,15 @@ export function addUsage(target, source) {
     target.cacheWrite += source.cacheWrite;
     target.total += source.total;
 }
+function negate(usage) {
+    return {
+        input: -usage.input,
+        output: -usage.output,
+        cacheRead: -usage.cacheRead,
+        cacheWrite: -usage.cacheWrite,
+        total: -usage.total,
+    };
+}
 class Sink {
     totals = new Map();
     counts = new Map();
@@ -98,20 +107,27 @@ export class Recorder {
             throw error;
         }
     }
-    summary() {
+    summary(since) {
         const total = emptyUsage();
         const roles = {};
         for (const [role, value] of this.sink.totals) {
-            roles[role] = value;
-            addUsage(total, value);
+            const earlier = since?.roles[role] ?? { ...emptyUsage(), calls: 0, ms: 0 };
+            if (value.calls === earlier.calls) {
+                continue;
+            }
+            const usage = { ...value, calls: value.calls - earlier.calls, ms: value.ms - earlier.ms };
+            addUsage(usage, negate(earlier));
+            roles[role] = usage;
+            addUsage(total, usage);
         }
-        return {
-            runId: this.runId,
-            logFile: this.sink.file,
-            roles,
-            counts: Object.fromEntries(this.sink.counts),
-            total,
-        };
+        const counts = {};
+        for (const [kind, value] of this.sink.counts) {
+            const count = value - (since?.counts[kind] ?? 0);
+            if (count > 0) {
+                counts[kind] = count;
+            }
+        }
+        return { runId: this.runId, logFile: this.sink.file, roles, counts, total };
     }
     async close() {
         await this.sink.close();

package/package.json

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