next-issue 0.14.1 → 0.15.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
@@ -131,7 +132,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 +188,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 +209,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 +242,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 |
@@ -263,7 +268,23 @@ The log gives the reason for a skipped issue as `stop-label`, `not-ready` or
 `in-flight`.
 
 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 +332,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/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

@@ -137,6 +137,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 +237,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 +331,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.15.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"
   }
 }