next-issue 1.0.6 → 1.0.8

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`,
@@ -21,11 +25,14 @@ For each open issue, oldest first:
    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
-   `issue-<n>` branch. A branch that exists on the remote is the start, and a
-   local branch that fell behind the remote is fast-forwarded. A fast-forward
-   of the base that is not safe leaves the local base branch as it is and
-   writes a `base.behind` event. A new branch then starts from the remote base.
+   that is safe, then add a git worktree at `.worktrees/<n>` in the
+   repository root on the `<n>` branch. An issue that resumes from saved
+   state keeps the branch name that the state holds, and a worktree that
+   holds that branch already stays in use. A branch that exists on the
+   remote is the start, and a local branch that fell behind the remote is
+   fast-forwarded. A fast-forward of the base that is not safe leaves the
+   local base branch as it is and writes a `base.behind` event. A new branch
+   then starts from the remote base.
 4. Let the implementer agent do the work, then commit and push. When a git
    hook stops a commit, the agent that made the change gets the hook output,
    fixes it, and the harness commits again. A `commit:` line in the reply of
@@ -229,9 +236,10 @@ npx -y next-issue@latest init
 ```
 
 The command writes `next-issue.config.json` in the root of the repository and
-adds `.next-issue/` to `.gitignore`. It stops when the config file is there
-already; `--force` replaces it. The file holds no `setupCommand`, because the
-harness deduces one from the lock file of the project.
+adds `.next-issue/` and `.worktrees/` to `.gitignore`. It stops when the
+config file is there already; `--force` replaces it. The file holds no
+`setupCommand`, because the harness deduces one from the lock file of the
+project.
 
 With no file, every field keeps its default. A field that is not in the file
 keeps its default. A file that cannot be read, a file that is not valid

package/dist/cli.mjs

@@ -4,7 +4,7 @@ import { join } from "node:path";
 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 { detectRepo, ensureIgnored, repoRoot, WORKTREE_DIR } from "./git.mjs";
 import { defaultBranch } from "./github.mjs";
 import { listenForInterrupts } from "./interrupt.mjs";
 import { exitCode, runIssues } from "./loop.mjs";
@@ -58,6 +58,9 @@ async function init(root, force) {
     if (await ensureIgnored(root, `${STATE_DIR}/`)) {
         await write(process.stdout, `added ${STATE_DIR}/ to .gitignore\n`);
     }
+    if (await ensureIgnored(root, `${WORKTREE_DIR}/`)) {
+        await write(process.stdout, `added ${WORKTREE_DIR}/ to .gitignore\n`);
+    }
     return 0;
 }
 async function handle(args, config, repo, recorder) {
@@ -79,16 +82,21 @@ 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 { reports, stoppedAt, error } = await runIssues(args, {
+        issues: async () => {
+            const issues = await pendingIssues(context);
+            recorder.event("issues", { open: issues.length }, "quiet");
+            return issues;
+        },
         process: (issue) => processIssue(context, issue),
         stop: interrupts.afterIssue,
     });
     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"),
@@ -100,7 +108,7 @@ async function handle(args, config, repo, recorder) {
     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);
+    return error === undefined ? exitCode(reports) : 1;
 }
 function count(reports, outcome) {
     return reports.filter((report) => report.outcome === outcome).length;

package/dist/git.mjs

@@ -1,5 +1,5 @@
 import { appendFile, readFile } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { join } from "node:path";
 import { must, run } from "./exec.mjs";
 const REMOTE_PATTERNS = [
     /^git@[^:]+:(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?$/,
@@ -24,18 +24,19 @@ export async function detectRepo(cwd, remote) {
     const { owner, name } = parseRemote(url);
     return { owner, name, root };
 }
+export const WORKTREE_DIR = ".worktrees";
 export function worktreePath(repo, issue) {
-    return join(dirname(repo.root), `${basename(repo.root)}-issue-${issue}`);
+    return join(repo.root, WORKTREE_DIR, String(issue));
 }
-export async function addWorktree(repo, issue, base, remote) {
-    const path = worktreePath(repo, issue);
-    const branch = branchName(issue);
+export async function addWorktree(repo, issue, branch, base, remote) {
     const upstream = `${remote}/${branch}`;
     await must("git", ["fetch", remote], { cwd: repo.root });
     const baseUpdated = await updateBase(repo, base, remote);
     await must("git", ["worktree", "prune"], { cwd: repo.root });
     const pushed = await hasBranch(repo, upstream, "--remotes");
-    if (!(await hasWorktree(repo, path))) {
+    const existing = await findWorktree(repo, branch);
+    const path = existing ?? worktreePath(repo, issue);
+    if (existing === undefined) {
         const args = (await hasBranch(repo, branch))
             ? ["worktree", "add", path, branch]
             : ["worktree", "add", "-b", branch, path, pushed ? upstream : `${remote}/${base}`];
@@ -58,12 +59,16 @@ export async function updateBase(repo, base, remote) {
     const result = await run("git", args, { cwd: repo.root });
     return result.code === 0;
 }
-export async function hasWorktree(repo, path) {
+export async function findWorktree(repo, branch) {
     const list = await must("git", ["worktree", "list", "--porcelain"], { cwd: repo.root });
-    return list.split("\n").some((line) => line.trim() === `worktree ${path}`);
-}
-export async function removeWorktree(repo, issue) {
-    const result = await run("git", ["worktree", "remove", worktreePath(repo, issue)], { cwd: repo.root });
+    const entry = list
+        .split("\n\n")
+        .map((block) => block.split("\n"))
+        .find((lines) => lines.includes(`branch refs/heads/${branch}`));
+    return entry?.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
+}
+export async function removeWorktree(repo, path) {
+    const result = await run("git", ["worktree", "remove", path], { cwd: repo.root });
     return result.code === 0;
 }
 export async function ensureIgnored(root, entry) {
@@ -83,7 +88,7 @@ export async function ensureIgnored(root, entry) {
     return true;
 }
 export function branchName(issue) {
-    return `issue-${issue}`;
+    return String(issue);
 }
 export async function isDirty(cwd) {
     const status = await must("git", ["status", "--porcelain"], { cwd });

package/dist/loop.mjs

@@ -1,9 +1,19 @@
 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) {

package/dist/pipeline.mjs

@@ -1,7 +1,7 @@
 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 { addWorktree, branchName, commitAll, deleteBranch, diff, discardChanges, findWorktree, isDirty, push, removeWorktree, resetToBase, revision, } from "./git.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";
@@ -20,7 +20,7 @@ export const PORTS = {
     failedBaseLogs,
     failedCheckLogs,
     findPr,
-    hasWorktree,
+    findWorktree,
     isDirty,
     issueComments,
     markPrReady,
@@ -126,7 +126,7 @@ export async function processIssue(context, issue) {
         catch (failure) {
             log.event("hand-over.error", { error: message(failure) }, "quiet");
         }
-        await cleanUp(context, log, issue.number);
+        await cleanUp(context, log, state.branch);
         return {
             issue: issue.number,
             outcome: "error",
@@ -150,7 +150,7 @@ async function work(context, issue, log, state) {
         await writeState(repo, state);
     });
     const comments = await log.step("comments", {}, () => ports.issueComments(repo, issue.number));
-    const added = await log.step("worktree", { branch }, () => ports.addWorktree(repo, issue.number, context.base, config.remote));
+    const added = await log.step("worktree", { branch }, () => ports.addWorktree(repo, issue.number, branch, context.base, config.remote));
     const worktree = added.path;
     if (!added.baseUpdated) {
         log.event("base.behind", { base: context.base }, "quiet");
@@ -477,7 +477,7 @@ function stop(job) {
 async function finish(job, outcome, reason) {
     const { context, issue, log, state, branch } = job;
     const { repo, ports } = context;
-    await cleanUp(context, log, issue.number);
+    await cleanUp(context, log, branch);
     if (outcome === "done") {
         if (!(await ports.deleteBranch(repo, branch))) {
             log.event("branch.kept", { branch }, "quiet");
@@ -556,13 +556,13 @@ async function commitWork(job, before, subject, role) {
         }
     }
 }
-async function cleanUp(context, log, issue) {
-    const path = worktreePath(context.repo, issue);
+async function cleanUp(context, log, branch) {
     try {
-        if (!(await context.ports.hasWorktree(context.repo, path))) {
+        const path = await context.ports.findWorktree(context.repo, branch);
+        if (path === undefined) {
             return;
         }
-        if (!(await context.ports.removeWorktree(context.repo, issue))) {
+        if (!(await context.ports.removeWorktree(context.repo, path))) {
             log.event("worktree.kept", { path }, "quiet");
         }
     }

package/package.json

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