next-issue 0.14.1 → 0.16.0

package/README.md

@@ -1,7 +1,8 @@
 # next-issue
 
 A small harness that works through the open issues of a GitHub repository with
-the Claude Agent SDK. Run it inside a git repository.
+the Claude Agent SDK, or with [pi](https://pi.dev). Run it inside a git
+repository.
 
 ```bash
 npx -y next-issue@latest
@@ -21,8 +22,10 @@ For each open issue, oldest first:
 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`,
    `status:needs-human` or `status:blocked` label always stops the claim, a
-   resume too. An issue with saved state under `.next-issue/` resumes instead,
-   whatever its other labels.
+   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.
 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
@@ -131,7 +134,8 @@ verdict.
 
 Every agent can run a shell command. The implementer and the fixer run with the
 permission checks off; the reviewer runs with a smaller tool set, but its shell
-has no limit on the commands. They all start in the worktree, but nothing holds
+has no limit on the commands. pi has no permission checks, so with the `pi`
+agent the reviewer only runs without the `edit` and `write` tools. They all start in the worktree, but nothing holds
 them there: they can run any command, with your rights, anywhere on the machine.
 The prompt holds the title, the body and the comments of the issue, which come
 from GitHub.
@@ -186,6 +190,7 @@ Three levels of console output:
 - `gh`, authenticated with write access to the repository
 - Anthropic credentials for the Claude Agent SDK: `ANTHROPIC_API_KEY`, or a
   Claude subscription login
+- With the `pi` agent: `pi` on the `PATH`, set up with a model instead
 
 ## Configuration
 
@@ -206,6 +211,7 @@ does not know all stop the run, so a typo cannot pass without a word.
 
 ```json
 {
+  "agent": "claude",
   "remote": "origin",
   "issueLimit": 100,
   "maxCiFixes": 5,
@@ -238,6 +244,7 @@ does not know all stop the run, so a typo cannot pass without a word.
 
 | Field | Default | Effect |
 | --- | --- | --- |
+| `agent` | `claude` | The agent that does the work: `claude` or `pi` |
 | `remote` | `origin` | The git remote for the repository and the branches |
 | `issueLimit` | `100` | The maximum number of open issues to read |
 | `maxCiFixes` | `5` | The budget for check fixes per issue |
@@ -259,11 +266,27 @@ does not know all stop the run, so a typo cannot pass without a word.
 An empty `labels.ready` turns the ready requirement off. The harness then
 claims every open issue that no other label holds back.
 
-The log gives the reason for a skipped issue as `stop-label`, `not-ready` or
-`in-flight`.
+The log gives the reason for a skipped issue as `stop-label`, `not-ready`,
+`in-flight` or `blocked`, the last one with the open blockers.
 
 A role set to `null`, or with no entry in `models`, uses the default model of
-the SDK.
+the agent.
+
+## The pi agent
+
+With `"agent": "pi"` or `--agent pi`, each agent call runs `pi --mode json` in
+the worktree with the prompt on standard input. pi loads your own settings,
+extensions, skills and context files, as it does when you run it yourself. The
+flag wins over the config file.
+
+- The implementer and the fixer use your default pi tools.
+- The reviewer runs with `--tools -edit,-write`, so it keeps `bash`.
+- A model in `models` goes to `pi --model` as it is, so use a name that pi
+  knows.
+- pi has no structured output, so the reviewer is asked to end its reply with
+  a JSON verdict. A reply with no valid verdict hands the issue to a person.
+- A run fails when its last reply ends with an error, when pi exits with an
+  error, or when pi stops before the run settles.
 
 Without a `setupCommand`, the harness looks in the new worktree for a lock file
 and runs the install command that goes with it:
@@ -311,6 +334,7 @@ that a label still holds back stays as it was.
 | `--force` | Replace an existing config file, with `init` |
 | `--once` | Stop after the first handled issue |
 | `--max <n>` | Handle at most n issues |
+| `--agent <a>` | Run the agents with `claude` or `pi`, whatever the config file says |
 | `--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 |

package/dist/agents.mjs

@@ -1,8 +1,10 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { emptyUsage } from "./observe.mjs";
+import { runPi } from "./pi.mjs";
 const REVIEWING = {
     tools: ["Read", "Grep", "Glob", "Bash"],
     permissionMode: "dontAsk",
+    piTools: "-edit,-write",
 };
 const CODING = {
     tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
@@ -11,6 +13,9 @@ const CODING = {
 };
 export { CODING, REVIEWING };
 export async function runAgent(recorder, request) {
+    if (request.agent === "pi") {
+        return runPi(recorder, request);
+    }
     const log = recorder.scope({ role: request.name });
     const usage = emptyUsage();
     const toolNames = new Map();
@@ -138,7 +143,7 @@ function main(models) {
     return name;
 }
 export function toolFields(name, input) {
-    if (name !== "Bash" || typeof input !== "object" || input === null) {
+    if ((name !== "Bash" && name !== "bash") || typeof input !== "object" || input === null) {
         return { tool: name };
     }
     const { command } = input;

package/dist/args.mjs

@@ -1,10 +1,11 @@
-import { CONFIG_FILE } from "./config.mjs";
+import { AGENT_NAMES, CONFIG_FILE } from "./config.mjs";
 export const USAGE = `next-issue [command] [options]
 
   init         write ${CONFIG_FILE} with the defaults
 
   --once       stop after the first handled issue
   --max <n>    handle at most n issues
+  --agent <a>  run the agents with claude or pi
   --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
@@ -51,6 +52,13 @@ export function parseArgs(argv) {
         else if (arg === "--quiet") {
             args.level = "quiet";
         }
+        else if (arg === "--agent") {
+            const value = argv[++index];
+            if (value === undefined || !AGENT_NAMES.includes(value)) {
+                throw new Error("--agent needs claude or pi");
+            }
+            args.agent = value;
+        }
         else if (arg === "--max") {
             args.max = whole(argv[++index], arg);
         }

package/dist/cli.mjs

@@ -28,6 +28,7 @@ async function main() {
         return init(root, args.force);
     }
     const config = await loadConfig(root);
+    config.agent = args.agent ?? config.agent;
     setDefaultTimeout(config.commandTimeoutMinutes * 60_000);
     const repo = await detectRepo(root, config.remote);
     const recorder = await Recorder.create(repo.root, args.level);

package/dist/config.mjs

@@ -1,7 +1,9 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { message } from "./observe.mjs";
+export const AGENT_NAMES = ["claude", "pi"];
 const DEFAULTS = {
+    agent: "claude",
     remote: "origin",
     issueLimit: 100,
     maxCiFixes: 5,
@@ -91,6 +93,12 @@ function parseConfig(value) {
         }
     }
     const config = defaults();
+    if (file.agent !== undefined) {
+        if (typeof file.agent !== "string" || !AGENT_NAMES.includes(file.agent)) {
+            throw new Error(`${CONFIG_FILE}: agent must be claude or pi.`);
+        }
+        config.agent = file.agent;
+    }
     if (file.remote !== undefined) {
         config.remote = text(file.remote, "remote", false);
     }

package/dist/exec.mjs

@@ -64,6 +64,7 @@ export function run(command, args, options = {}) {
         child.stdout?.setEncoding("utf8");
         child.stderr?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => {
+            options.onStdout?.(chunk);
             stdout += chunk;
             if (options.tailChars !== undefined && stdout.length > options.tailChars) {
                 stdout = stdout.slice(-options.tailChars);

package/dist/github.mjs

@@ -44,6 +44,19 @@ export async function issueComments(repo, issue) {
     const parsed = JSON.parse(raw);
     return parsed.comments.map((comment) => `@${comment.author.login}: ${comment.body}`);
 }
+export async function openBlockers(repo, issue) {
+    const raw = await must("gh", [
+        "api",
+        "--paginate",
+        `repos/${slug(repo)}/issues/${issue}/dependencies/blocked_by`,
+        "--jq",
+        '.[] | select(.state == "open") | (.repository_url | split("/") | .[-2:] | join("/")) + "#" + (.number | tostring)',
+    ], { cwd: repo.root });
+    return raw
+        .split("\n")
+        .filter((line) => line.length > 0)
+        .map((ref) => (ref.startsWith(`${slug(repo)}#`) ? ref.slice(slug(repo).length) : ref));
+}
 async function labelsOf(repo, kind, number) {
     const raw = await gh(repo, [kind, "view", String(number), "--json", "labels"]);
     const parsed = JSON.parse(raw);

package/dist/pi.mjs

@@ -0,0 +1,159 @@
+import { toolFields } from "./agents.mjs";
+import { run } from "./exec.mjs";
+import { emptyUsage } from "./observe.mjs";
+const NO_LIMIT = 2 ** 31 - 1;
+const OUTPUT_TAIL = 200_000;
+export async function runPi(recorder, request) {
+    const log = recorder.scope({ role: request.name });
+    const usage = emptyUsage();
+    let text = "";
+    let toolCalls = 0;
+    let turns = 0;
+    let costUsd = 0;
+    let model = request.model;
+    let sessionId;
+    let settled = false;
+    let last;
+    const read = (line) => {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (event.type === "session") {
+            sessionId = event.id;
+        }
+        else if (event.type === "message_end" && event.message?.role === "assistant") {
+            const message = event.message;
+            last = message;
+            turns += 1;
+            model = message.model ?? model;
+            const input = message.usage?.input ?? 0;
+            const output = message.usage?.output ?? 0;
+            const cacheRead = message.usage?.cacheRead ?? 0;
+            const cacheWrite = message.usage?.cacheWrite ?? 0;
+            usage.input += input;
+            usage.output += output;
+            usage.cacheRead += cacheRead;
+            usage.cacheWrite += cacheWrite;
+            usage.total += input + output + cacheRead + cacheWrite;
+            costUsd += message.usage?.cost?.total ?? 0;
+            const said = textOf(message.content);
+            if (said.length > 0) {
+                text = said;
+                if (log.level === "verbose") {
+                    process.stderr.write(said);
+                }
+            }
+        }
+        else if (event.type === "tool_execution_start") {
+            toolCalls += 1;
+            log.event("tool", toolFields(event.toolName ?? "unknown", event.args));
+        }
+        else if (event.type === "tool_execution_end" && event.isError === true) {
+            log.event("tool.error", { tool: event.toolName }, "quiet");
+        }
+        else if (event.type === "agent_settled") {
+            settled = true;
+        }
+    };
+    const started = Date.now();
+    log.event("agent.start", { model: request.model, timeoutMs: request.timeoutMs, agent: "pi" }, "normal");
+    let rest = "";
+    const result = await run("pi", piArgs(request), {
+        cwd: request.cwd,
+        input: piPrompt(request),
+        timeoutMs: request.timeoutMs ?? NO_LIMIT,
+        tailChars: OUTPUT_TAIL,
+        onStdout: (chunk) => {
+            rest += chunk;
+            let end = rest.indexOf("\n");
+            while (end !== -1) {
+                read(rest.slice(0, end).replace(/\r$/, ""));
+                rest = rest.slice(end + 1);
+                end = rest.indexOf("\n");
+            }
+        },
+    });
+    if (rest.length > 0) {
+        read(rest);
+    }
+    const failed = (reason) => new Error(`The ${request.name} agent failed: ${reason}`);
+    if (result.timedOut) {
+        throw new Error(`The ${request.name} agent did not finish in ${request.timeoutMs} ms.`);
+    }
+    if (last?.stopReason === "error" || last?.stopReason === "aborted") {
+        throw failed(last.errorMessage ?? last.stopReason);
+    }
+    if (result.code !== 0) {
+        throw failed(`pi exited with code ${result.code}: ${result.stderr.trim()}`);
+    }
+    if (!settled) {
+        throw failed("pi stopped before the run settled");
+    }
+    if (last?.stopReason === "length") {
+        log.event("agent.incomplete", { subtype: "length" }, "quiet");
+    }
+    const ms = Date.now() - started;
+    recorder.usage(request.name, usage, ms, {
+        turns,
+        toolCalls,
+        model,
+        session: sessionId,
+        costUsd,
+    });
+    return {
+        text: text.trim(),
+        usage,
+        turns,
+        toolCalls,
+        ms,
+        costUsd,
+        model,
+        sessionId,
+        structured: request.outputSchema === undefined ? undefined : jsonOf(text),
+    };
+}
+function piArgs(request) {
+    return [
+        "--mode",
+        "json",
+        ...(request.model === undefined ? [] : ["--model", request.model]),
+        ...(request.profile.piTools === undefined ? [] : ["--tools", request.profile.piTools]),
+    ];
+}
+function piPrompt(request) {
+    if (request.outputSchema === undefined) {
+        return request.prompt;
+    }
+    return [
+        request.prompt,
+        "",
+        "End your reply with only a JSON object in a json code block. The object must match this JSON schema:",
+        JSON.stringify(request.outputSchema),
+    ].join("\n");
+}
+function textOf(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .filter((block) => block?.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("");
+}
+function jsonOf(text) {
+    const fenced = [...text.matchAll(/```(?:json)?[ \t]*\n([\s\S]*?)```/g)].at(-1)?.[1];
+    const candidate = fenced ?? text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1);
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/pipeline.mjs

@@ -2,7 +2,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, revision, worktreePath, } from "./git.mjs";
-import { commentOnPr, createPr, failedCheckLogs, findPr, issueComments, markPrReady, setLabel, waitForChecks, } from "./github.mjs";
+import { commentOnPr, createPr, failedCheckLogs, findPr, issueComments, markPrReady, openBlockers, setLabel, waitForChecks, } from "./github.mjs";
 import { message } from "./observe.mjs";
 import { capDiff, fixPrompt, implementPrompt, parseCommitSubject, parseUnrelated, reviewPrompt, } from "./prompts.mjs";
 import { detectSetupCommand } from "./setup.mjs";
@@ -23,6 +23,7 @@ export const PORTS = {
     isDirty,
     issueComments,
     markPrReady,
+    openBlockers,
     push,
     removeWorktree,
     revision,
@@ -55,7 +56,21 @@ export async function processIssue(context, issue) {
     const skip = skipReason(issue, context.config, saved !== undefined);
     if (skip !== undefined) {
         log.event("issue.skip", { title: issue.title, reason: skip });
-        return { issue: issue.number, outcome: "skipped", ciFixes: 0, reviewRounds: 0, ms: 0 };
+        return skipped(issue);
+    }
+    if (saved === undefined) {
+        let blockers;
+        try {
+            blockers = await context.ports.openBlockers(context.repo, issue.number);
+        }
+        catch (error) {
+            log.event("issue.error", { error: message(error), ms: Date.now() - started }, "quiet");
+            return { ...skipped(issue), outcome: "error", reason: message(error), ms: Date.now() - started };
+        }
+        if (blockers.length > 0) {
+            log.event("issue.skip", { title: issue.title, reason: "blocked", blockers });
+            return skipped(issue);
+        }
     }
     log.event("issue.start", { title: issue.title, createdAt: issue.createdAt }, "quiet");
     const fresh = {
@@ -92,6 +107,9 @@ export async function processIssue(context, issue) {
         };
     }
 }
+function skipped(issue) {
+    return { issue: issue.number, outcome: "skipped", ciFixes: 0, reviewRounds: 0, ms: 0 };
+}
 async function work(context, issue, log, state) {
     const started = Date.now();
     const { repo, config, ports } = context;
@@ -137,6 +155,7 @@ async function work(context, issue, log, state) {
             prompt: implementPrompt(issue, comments),
             profile: CODING,
             model: config.models.implementer,
+            agent: config.agent,
             timeoutMs: config.agentTimeoutMinutes * 60_000,
         }));
         const subject = parseCommitSubject(result.text, `fix: resolve issue #${issue.number}`);
@@ -236,6 +255,7 @@ async function reviewRound(job) {
         prompt: reviewPrompt(issue, comments, patch, history(state.reviewLog)),
         profile: REVIEWING,
         model: config.models.reviewer,
+        agent: config.agent,
         timeoutMs: config.agentTimeoutMinutes * 60_000,
         outputSchema: VERDICT_SCHEMA,
     }));
@@ -329,6 +349,7 @@ async function fixRound(job, reason, detail, earlier, kind) {
         prompt: fixPrompt(issue, reason, detail, earlier, kind),
         profile: CODING,
         model: context.config.models.fixer,
+        agent: context.config.agent,
         timeoutMs: context.config.agentTimeoutMinutes * 60_000,
     }));
     const unrelated = parseUnrelated(result.text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-issue",
-  "version": "0.14.1",
+  "version": "0.16.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.4.1",
+    "@types/node": "^26.6.5",
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.261"
+    "@anthropic-ai/claude-agent-sdk": "^0.3.310"
   }
 }