next-issue 0.8.1 → 0.9.0

package/README.md

@@ -21,8 +21,9 @@ For each open issue, oldest first:
 1. Claim the issue only when it holds the `status:todo` label, holds no
    `status:in-progress` or `status:in-review` label, and has no assignee. A
    `status:done`, `status:needs-human` or `status:blocked` label always stops
-   the claim. An issue with saved state under `.next-issue/` resumes instead,
-   whatever its labels, unless another person is now the assignee.
+   the claim, a resume too. An issue with saved state under `.next-issue/`
+   resumes instead, whatever its other labels, unless another person is now the
+   assignee.
 2. Assign the issue to you and add `status:in-progress`.
 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
@@ -111,6 +112,9 @@ Every run has an id, `<timestamp>`, and writes two files under
   one report per issue with the outcome, the reason, the pull request number
   and the budgets used.
 
+At the start of a run, the harness deletes the files under `.next-issue/runs/`
+that are older than `keepRunDays`. Set the field to `0` to keep them all.
+
 A short text summary of the same data goes to standard output. Use `--json` to
 get the full summary object there instead, so the harness fits in a pipe. All
 progress goes to standard error.
@@ -175,6 +179,7 @@ does not know all stop the run, so a typo cannot pass without a word.
   "commandTimeoutMinutes": 10,
   "logMaxChars": 20000,
   "diffMaxChars": 60000,
+  "keepRunDays": 7,
   "draftPullRequest": true,
   "models": {},
   "labels": {
@@ -200,8 +205,9 @@ does not know all stop the run, so a typo cannot pass without a word.
 | `agentTimeoutMinutes` | `30` | The limit for one agent call |
 | `setupTimeoutMinutes` | `15` | The limit for the setup command |
 | `commandTimeoutMinutes` | `10` | The limit for one `git` or `gh` command |
-| `logMaxChars` | `20000` | The maximum length of the failed job logs |
+| `logMaxChars` | `20000` | The maximum length of the failed job logs, shared between the failed jobs |
 | `diffMaxChars` | `60000` | The maximum length of the diff that the reviewer reads |
+| `keepRunDays` | `7` | The number of days to keep the run files; `0` keeps them all |
 | `draftPullRequest` | `true` | Open the pull request as a draft, until the review approves |
 | `setupCommand` | none | A shell command to run in a new worktree, before the implementer |
 | `models` | `{}` | The model per agent role |
@@ -228,6 +234,8 @@ would hand the issue over again at once. To give the issue another try, take the
 and the findings back to zero and keeps the branch, the pull request and the
 step that the last run reached, so the work carries on where it stopped. A
 commit that you pushed to the pull request in the meantime is fetched first.
+The flag touches only an issue that the run handles, so the state of an issue
+that a label still holds back stays as it was.
 
 ## Commands and options
 
@@ -243,6 +251,9 @@ commit that you pushed to the pull request in the meantime is fetched first.
 | `--quiet` | Show only the milestones and the summary |
 | `--help` | Show the option list |
 
+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.
+
 ## Development
 
 ```bash

package/dist/cli.mjs

@@ -7,9 +7,9 @@ import { setCommandObserver, setDefaultTimeout } from "./exec.mjs";
 import { detectRepo, ensureIgnored, repoRoot } from "./git.mjs";
 import { currentLogin, defaultBranch, openIssues } from "./github.mjs";
 import { exitCode, runIssues } from "./loop.mjs";
-import { message, Recorder } from "./observe.mjs";
+import { message, pruneRuns, Recorder } from "./observe.mjs";
 import { PORTS, processIssue } from "./pipeline.mjs";
-import { resetState, STATE_DIR, takeStop } from "./state.mjs";
+import { STATE_DIR, takeStop } from "./state.mjs";
 import { formatSummary } from "./summary.mjs";
 function write(stream, text) {
     return new Promise((resolve, reject) => {
@@ -30,6 +30,10 @@ async function main() {
     setDefaultTimeout(config.commandTimeoutMinutes * 60_000);
     const repo = await detectRepo(root, config.remote);
     const recorder = await Recorder.create(repo.root, args.level);
+    const pruned = await pruneRuns(repo.root, config.keepRunDays);
+    if (pruned > 0) {
+        recorder.event("runs.pruned", { files: pruned, keepDays: config.keepRunDays }, "verbose");
+    }
     setCommandObserver((record) => {
         recorder.event(record.code === 0 ? "command" : "command.fail", {
             cmd: `${record.command} ${record.args.join(" ")}`,
@@ -56,27 +60,26 @@ async function init(root, force) {
 }
 async function handle(args, config, repo, recorder) {
     const [base, login] = await Promise.all([defaultBranch(repo), currentLogin(repo)]);
-    const context = { repo, config, base, login, recorder, ports: PORTS };
+    const context = { repo, config, base, login, reset: args.reset, recorder, ports: PORTS };
     recorder.event("run.start", { repo: `${repo.owner}/${repo.name}`, base, login, log: recorder.logFile }, "quiet");
     const issues = await openIssues(repo, config.issueLimit);
     recorder.event("issues", { open: issues.length }, "quiet");
     const { reports, stoppedAt } = await runIssues(args, {
         issues,
         process: (issue) => processIssue(context, issue),
-        reset: (issue) => resetState(repo, issue),
         stop: () => takeStop(repo),
     });
     if (stoppedAt !== undefined) {
         recorder.event("run.stop", { issue: stoppedAt }, "quiet");
     }
-    const summary = { ...recorder.summary(), issues: reports };
     recorder.event("run.end", {
         done: count(reports, "done"),
         needsHuman: count(reports, "needs-human"),
         failed: count(reports, "error"),
         skipped: count(reports, "skipped"),
-        tokens: summary.total.total,
+        tokens: recorder.summary().total.total,
     }, "quiet");
+    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));

package/dist/config.mjs

@@ -14,6 +14,7 @@ const DEFAULTS = {
     commandTimeoutMinutes: 10,
     logMaxChars: 20000,
     diffMaxChars: 60000,
+    keepRunDays: 7,
     draftPullRequest: true,
     models: {},
     labels: {
@@ -38,6 +39,7 @@ const WHOLE_FIELDS = [
     ["commandTimeoutMinutes", 1],
     ["logMaxChars", 1],
     ["diffMaxChars", 1],
+    ["keepRunDays", 0],
 ];
 const MODEL_ROLES = ["implementer", "reviewer", "fixer"];
 const LABEL_NAMES = ["ready", "inProgress", "inReview", "done", "needsHuman", "skip"];

package/dist/exec.mjs

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 let observer;
 let defaultTimeoutMs = 10 * 60_000;
+const STDERR_TAIL = 200_000;
 export function setCommandObserver(next) {
     observer = next;
 }
@@ -30,20 +31,19 @@ export function run(command, args, options = {}) {
                 stdout = stdout.slice(-options.tailChars);
             }
         });
+        const stderrLimit = options.tailChars ?? STDERR_TAIL;
         child.stderr?.on("data", (chunk) => {
             stderr += chunk;
+            if (stderr.length > stderrLimit) {
+                stderr = stderr.slice(-stderrLimit);
+            }
         });
         const timer = setTimeout(() => {
             timedOut = true;
             child.kill("SIGKILL");
         }, limit);
         let done = false;
-        child.on("error", (error) => {
-            clearTimeout(timer);
-            done = true;
-            reject(error);
-        });
-        child.on("close", (code) => {
+        const settle = (code) => {
             clearTimeout(timer);
             if (done) {
                 return;
@@ -60,7 +60,21 @@ export function run(command, args, options = {}) {
                 timedOut,
             });
             resolve(result);
+        };
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            done = true;
+            reject(error);
+        });
+        child.on("exit", (code) => {
+            if (!timedOut) {
+                return;
+            }
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            settle(code);
         });
+        child.on("close", settle);
         if (options.input !== undefined) {
             child.stdin?.on("error", () => undefined);
             child.stdin?.end(options.input);

package/dist/github.mjs

@@ -78,8 +78,12 @@ export async function ensureLabel(repo, label) {
     if (known.has(label)) {
         return;
     }
-    await run("gh", ["label", "create", label, "--repo", slug(repo)], { cwd: repo.root });
-    known.add(label);
+    const result = await run("gh", ["label", "create", label, "--repo", slug(repo)], {
+        cwd: repo.root,
+    });
+    if (result.code === 0) {
+        known.add(label);
+    }
 }
 export async function findPr(repo, branch) {
     const result = await run("gh", ["pr", "list", "--head", branch, "--state", "open", "--json", "number", "--repo", slug(repo)], { cwd: repo.root });
@@ -90,7 +94,7 @@ export async function findPr(repo, branch) {
     return parsed[0]?.number;
 }
 export async function createPr(repo, branch, base, title, body, draft) {
-    await gh(repo, [
+    const created = await gh(repo, [
         "pr",
         "create",
         "--head",
@@ -103,12 +107,16 @@ export async function createPr(repo, branch, base, title, body, draft) {
         body,
         ...(draft ? ["--draft"] : []),
     ]);
-    const number = await findPr(repo, branch);
+    const number = prNumber(created) ?? (await findPr(repo, branch));
     if (number === undefined) {
         throw new Error(`The pull request for ${branch} was not found after creation.`);
     }
     return number;
 }
+export function prNumber(output) {
+    const match = /\/pull\/(\d+)\b/.exec(output);
+    return match === null ? undefined : Number(match[1]);
+}
 async function prHead(repo, branch) {
     return gh(repo, ["pr", "view", branch, "--json", "headRefOid", "--jq", ".headRefOid"]);
 }
@@ -178,11 +186,11 @@ async function read(probe, head, timeoutMs, shown) {
         if ((await probe.list()) === "none") {
             return "none";
         }
+        return await probe.watch(timeoutMs);
     }
     catch (error) {
         return error instanceof Error ? error : new Error(String(error));
     }
-    return probe.watch(timeoutMs);
 }
 export function waitForChecks(repo, branch, options) {
     return pollChecks({
@@ -197,6 +205,7 @@ export async function failedCheckLogs(repo, branch, maxChars) {
         return "The checks failed, but gh reports no check for the branch.";
     }
     const failed = checks.filter((check) => check.bucket === "fail");
+    const share = Math.max(1, Math.floor(maxChars / Math.max(1, failed.length)));
     const parts = [];
     for (const check of failed) {
         parts.push(`## ${check.name}\n${check.description}`);
@@ -206,11 +215,11 @@ export async function failedCheckLogs(repo, branch, maxChars) {
         }
         const logs = await run("gh", ["run", "view", runId, "--log-failed", "--repo", slug(repo)], {
             cwd: repo.root,
-            tailChars: maxChars,
+            tailChars: share,
         });
-        parts.push(logs.stdout.slice(-maxChars));
+        parts.push(logs.stdout.slice(-share));
     }
-    return parts.join("\n\n").slice(-maxChars);
+    return parts.join("\n\n");
 }
 export async function markPrReady(repo, pr) {
     const result = await run("gh", ["pr", "ready", String(pr), "--repo", slug(repo)], {

package/dist/loop.mjs

@@ -5,9 +5,6 @@ export async function runIssues(args, loop) {
         if (args.max !== undefined && handled(reports) >= args.max) {
             break;
         }
-        if (args.reset) {
-            await loop.reset(issue.number);
-        }
         const report = await loop.process(issue);
         reports.push(report);
         if (await loop.stop()) {

package/dist/observe.mjs

@@ -1,5 +1,5 @@
 import { createWriteStream } from "node:fs";
-import { mkdir } from "node:fs/promises";
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { STATE_DIR } from "./state.mjs";
 const VISIBILITY = { quiet: 0, normal: 1, verbose: 2 };
@@ -117,6 +117,35 @@ export class Recorder {
         await this.sink.close();
     }
 }
+export async function pruneRuns(root, keepDays) {
+    if (keepDays <= 0) {
+        return 0;
+    }
+    const dir = join(root, STATE_DIR, "runs");
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return 0;
+    }
+    const cutoff = Date.now() - keepDays * 24 * 60 * 60_000;
+    let dropped = 0;
+    for (const name of names) {
+        const path = join(dir, name);
+        try {
+            const info = await stat(path);
+            if (info.isFile() && info.mtimeMs < cutoff) {
+                await rm(path, { force: true });
+                dropped += 1;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return dropped;
+}
 export function message(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/pipeline.mjs

@@ -5,7 +5,7 @@ import { addWorktree, branchName, commitAll, deleteBranch, diff, hasWorktree, pu
 import { assignIssue, commentOnPr, createPr, failedCheckLogs, findPr, issueComments, markPrReady, setLabel, waitForChecks, } from "./github.mjs";
 import { message } from "./observe.mjs";
 import { capDiff, fixPrompt, implementPrompt, parseCommitSubject, parseUnrelated, reviewPrompt, } from "./prompts.mjs";
-import { dropState, readState, writeState } from "./state.mjs";
+import { dropState, readState, resetState, writeState, } from "./state.mjs";
 import { blockingFindings, fingerprint, formatFindings, formatVerdict, isApproved, readVerdict, VERDICT_SCHEMA, } from "./verdict.mjs";
 export const PORTS = {
     addWorktree,
@@ -55,7 +55,7 @@ export async function processIssue(context, issue) {
         return { issue: issue.number, outcome: "skipped", ciFixes: 0, reviewRounds: 0, ms: 0 };
     }
     log.event("issue.start", { title: issue.title, createdAt: issue.createdAt }, "quiet");
-    const state = saved ?? {
+    const fresh = {
         issue: issue.number,
         phase: "claimed",
         branch: branchName(issue.number),
@@ -63,6 +63,7 @@ export async function processIssue(context, issue) {
         reviewRounds: 0,
         reviewLog: [],
     };
+    const state = saved === undefined ? fresh : context.reset ? resetState(saved) : saved;
     try {
         const report = await work(context, issue, log, state);
         log.event("issue.end", { outcome: report.outcome, reason: report.reason, ms: report.ms }, "quiet");

package/dist/state.mjs

@@ -15,15 +15,10 @@ export async function readState(repo, issue) {
         return undefined;
     }
 }
-export async function resetState(repo, issue) {
-    const state = await readState(repo, issue);
-    if (state === undefined) {
-        return false;
-    }
+export function resetState(state) {
     const next = { ...state, ciFixes: 0, reviewRounds: 0, reviewLog: [] };
     delete next.handedOver;
-    await writeState(repo, next);
-    return true;
+    return next;
 }
 export async function writeState(repo, state) {
     await mkdir(dir(repo), { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-issue",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Autonomous issue harness driven by the Claude Agent SDK",
   "keywords": [
     "github",
@@ -37,10 +37,10 @@
     "prepublishOnly": "npm run typecheck && npm test"
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.241"
+    "@anthropic-ai/claude-agent-sdk": "^0.3.261"
   }
 }