next-issue 1.1.0 → 2.0.0

package/README.md

@@ -1,7 +1,7 @@
 # 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 [pi](https://github.com/earendil-works/pi) SDK. Run it inside a git repository.
 
 ```bash
 npx -y next-issue@latest
@@ -54,7 +54,7 @@ and exits with code 1. For each issue:
    reviewer reads files and runs commands in the worktree, so it can prove a
    finding with the tests or the type check. The harness then throws away every
    change that the reviewer left, so no such change can reach a later commit.
-   The reviewer returns a structured verdict: a summary and one entry per
+   The reviewer returns its verdict with a `submit_result` tool: a summary and one entry per
    finding, each rated `blocking` or `minor`. The findings are the only ground
    truth. The reviewer gives no approve or reject field, because such a field
    can contradict the findings. The harness puts the result on the pull
@@ -146,14 +146,14 @@ Press `Ctrl-C` to stop the run step by step:
    one checks round (wait, then fix) or one review round (review, then fix). The
    issue ends as `stopped`. Its state, worktree and labels stay, so the next run
    carries on from that point.
-3. The third press kills the command that runs and every child of it, so the run
-   dies in the middle of a step. The saved state lets the next run continue the
+3. The third press stops every agent, kills the command that runs and every
+   child of it, so the run dies in the middle of a step. The saved state lets the next run continue the
    issue, but the issue keeps `status:in-progress` and the run writes no
    summary.
 
 Each of the first two presses prints a line that says what happens next. The
-agents and commands run in a process group of their own, so a press reaches only
-the harness.
+agents run inside the harness, and their commands and the harness commands run
+in a process group of their own, so a press reaches only the harness.
 
 A status label that the harness puts on the issue goes on the pull request too,
 but only if the pull request exists at that moment. The `status:in-progress`
@@ -202,10 +202,9 @@ Recorded for each step: `claim`, `comments`, `worktree`, `setup`, `implement`,
 `push`, `pull-request`, `checks`, `review` and `fix`, each with a `.start`,
 `.end` or `.error` event and a duration in `ms`. Every `git` and `gh` command
 is recorded with its exit code and duration. A `tool` event holds the tool
-name, and for a `Bash` tool the command too. Each agent call adds a `usage`
+name, and for a `bash` tool the command too. Each agent call adds a `usage`
 event with the tokens, the cost estimate in dollars, the turn count, the
-tool-call count, the model and the session id, so you can open the session
-again and read the full transcript.
+tool-call count, the model and the session id.
 
 ```bash
 jq -r 'select(.kind=="usage") | [.issue,.role,.turns,.total] | @tsv' \
@@ -224,8 +223,11 @@ Three levels of console output:
 
 - Node 24 or later
 - `gh`, authenticated with write access to the repository
-- Anthropic credentials for the Claude Agent SDK: `ANTHROPIC_API_KEY`, or a
-  Claude subscription login
+- pi, logged in to a model provider. The agents use the model, the thinking
+  level and the extensions from your pi settings, except the `pi-next-issue`
+  extension. The implementer and the fixer get the `read`, `bash`, `edit`,
+  `write`, `grep`, `find` and `ls` tools, and the reviewer gets all of them
+  except `edit` and `write`.
 
 ## Configuration
 
@@ -297,7 +299,7 @@ does not know all stop the run, so a typo cannot pass without a word.
 | `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` | from the lock file | A shell command to run in a new worktree, before the implementer |
-| `models` | `null` per role | The model per agent role: `implementer`, `reviewer`, `fixer` |
+| `models` | `null` per role | The pi model per agent role, as `provider/model`: `implementer`, `reviewer`, `fixer` |
 | `labels` | see above | The names of the labels that the harness reads and sets |
 
 An empty `labels.ready` turns the ready requirement off. The harness then
@@ -307,7 +309,7 @@ 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 agent.
+your pi settings.
 
 Without a `setupCommand`, the harness looks in the new worktree for a lock file
 and runs the install command that goes with it:

package/dist/agents.mjs

@@ -1,186 +1,147 @@
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { spawn } from "node:child_process";
-import { once } from "node:events";
-import { setTimeout as delay } from "node:timers/promises";
-import { track } from "./exec.mjs";
+import { join, sep } from "node:path";
+import { createAgentSession, DefaultResourceLoader, defineTool, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { onStop } from "./exec.mjs";
 import { emptyUsage } from "./observe.mjs";
 const REVIEWING = {
-    tools: ["Read", "Grep", "Glob", "Bash"],
-    permissionMode: "dontAsk",
+    tools: ["read", "bash", "grep", "find", "ls"],
 };
 const CODING = {
-    tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
-    permissionMode: "bypassPermissions",
-    allowDangerouslySkipPermissions: true,
+    tools: ["read", "bash", "edit", "write", "grep", "find", "ls"],
 };
 export { CODING, REVIEWING };
-const STDERR_TAIL = 2000;
-const STDERR_GRACE_MS = 500;
+export const SUBMIT_TOOL = "submit_result";
+export function isOwnExtension(path) {
+    return path.split(sep).includes("pi-next-issue");
+}
 export async function runAgent(recorder, request) {
     const log = recorder.scope({ role: request.name });
-    const usage = emptyUsage();
-    const toolNames = new Map();
-    let text = "";
-    let toolCalls = 0;
-    let turns = 0;
-    let costUsd = 0;
-    let model = request.model;
-    let sessionId;
-    let structured;
-    let stderr = "";
-    let stderrClosed = Promise.resolve();
+    const runtime = request.runtime ?? {};
+    const agentDir = runtime.agentDir ?? getAgentDir();
     const started = Date.now();
     log.event("agent.start", { model: request.model, timeoutMs: request.timeoutMs }, "normal");
-    const controller = new AbortController();
+    let structured;
+    const customTools = [];
+    if (request.outputSchema !== undefined) {
+        customTools.push(defineTool({
+            name: SUBMIT_TOOL,
+            label: "Submit result",
+            description: "Give the result. Call it once, as your last action.",
+            parameters: request.outputSchema,
+            async execute(_toolCallId, params) {
+                structured = params;
+                return {
+                    content: [{ type: "text", text: "Result saved." }],
+                    details: {},
+                    terminate: true,
+                };
+            },
+        }));
+    }
+    const resourceLoader = new DefaultResourceLoader({
+        cwd: request.cwd,
+        agentDir,
+        extensionsOverride: (base) => ({
+            ...base,
+            extensions: base.extensions.filter((extension) => !isOwnExtension(extension.resolvedPath)),
+        }),
+    });
+    await resourceLoader.reload();
+    const modelRuntime = runtime.modelRuntime ?? (await ModelRuntime.create({
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: join(agentDir, "models.json"),
+    }));
+    const model = request.model === undefined ? undefined : await findModel(modelRuntime, request.model);
+    const { session, modelFallbackMessage } = await createAgentSession({
+        cwd: request.cwd,
+        agentDir,
+        resourceLoader,
+        sessionManager: SessionManager.inMemory(request.cwd),
+        tools: [...request.profile.tools, ...customTools.map((tool) => tool.name)],
+        customTools,
+        modelRuntime,
+        ...(runtime.settingsManager === undefined ? {} : { settingsManager: runtime.settingsManager }),
+        ...(model === undefined ? {} : { model }),
+    });
+    if (modelFallbackMessage !== undefined) {
+        log.event("agent.model", { note: modelFallbackMessage }, "quiet");
+    }
+    let timedOut = false;
     const timer = request.timeoutMs === undefined
         ? undefined
-        : setTimeout(() => controller.abort(), request.timeoutMs);
-    const late = () => new Error(`The ${request.name} agent did not finish in ${request.timeoutMs} ms.`);
+        : setTimeout(() => {
+            timedOut = true;
+            void session.abort();
+        }, request.timeoutMs);
+    const unsubscribe = session.subscribe((event) => observe(log, event));
+    const release = onStop(() => void session.abort());
     try {
-        const stream = query({
-            prompt: request.prompt,
-            options: {
-                cwd: request.cwd,
-                model: request.model,
-                tools: request.profile.tools,
-                allowedTools: request.profile.tools,
-                permissionMode: request.profile.permissionMode,
-                allowDangerouslySkipPermissions: request.profile.allowDangerouslySkipPermissions,
-                systemPrompt: { type: "preset", preset: "claude_code" },
-                abortController: controller,
-                pathToClaudeCodeExecutable: request.executable,
-                spawnClaudeCodeProcess: (options) => {
-                    const child = spawnClaude(options, (chunk) => {
-                        stderr = (stderr + chunk).slice(-STDERR_TAIL);
-                    });
-                    stderrClosed = once(child.stderr, "close").catch(() => undefined);
-                    return child;
-                },
-                outputFormat: request.outputSchema === undefined
-                    ? undefined
-                    : { type: "json_schema", schema: request.outputSchema },
-            },
-        });
-        for await (const message of stream) {
-            if (message.type === "assistant") {
-                for (const block of message.message.content) {
-                    if (block.type === "tool_use") {
-                        toolCalls += 1;
-                        toolNames.set(block.id, block.name);
-                        log.event("tool", toolFields(block.name, block.input));
-                    }
-                    if (block.type === "text") {
-                        text += block.text;
-                        if (log.level === "verbose") {
-                            process.stderr.write(block.text);
-                        }
-                    }
-                }
-            }
-            if (message.type === "user" && Array.isArray(message.message.content)) {
-                for (const block of message.message.content) {
-                    if (block.type === "tool_result" && block.is_error === true) {
-                        log.event("tool.error", { tool: toolNames.get(block.tool_use_id) }, "quiet");
-                    }
-                }
-            }
-            if (message.type === "result") {
-                sessionId = message.session_id;
-                turns = message.num_turns;
-                costUsd = message.total_cost_usd;
-                model = main(message.modelUsage) ?? model;
-                for (const entry of Object.values(message.modelUsage)) {
-                    usage.input += entry.inputTokens;
-                    usage.output += entry.outputTokens;
-                    usage.cacheRead += entry.cacheReadInputTokens;
-                    usage.cacheWrite += entry.cacheCreationInputTokens;
-                    usage.total +=
-                        entry.inputTokens +
-                            entry.outputTokens +
-                            entry.cacheReadInputTokens +
-                            entry.cacheCreationInputTokens;
-                }
-                if (message.subtype === "error_during_execution") {
-                    throw new Error(`The ${request.name} agent failed: ${message.errors.join("; ")}`);
-                }
-                if (message.subtype === "success") {
-                    text = message.result.length > 0 ? message.result : text;
-                    structured = message.structured_output;
-                }
-                else {
-                    log.event("agent.incomplete", { subtype: message.subtype }, "quiet");
-                }
-            }
+        await session.bindExtensions({});
+        await session.prompt(request.prompt, { expandPromptTemplates: false });
+        if (timedOut) {
+            throw new Error(`The ${request.name} agent did not finish in ${request.timeoutMs} ms.`);
         }
-    }
-    catch (error) {
-        if (controller.signal.aborted) {
-            throw late();
+        const last = session.messages.findLast((message) => message.role === "assistant");
+        if (last !== undefined && "stopReason" in last && last.stopReason === "error") {
+            throw new Error(`The ${request.name} agent failed: ${last.errorMessage ?? "no reason given"}`);
         }
-        await Promise.race([stderrClosed, delay(STDERR_GRACE_MS, undefined, { ref: false })]);
-        throw withStderr(error, stderr);
+        const stats = session.getSessionStats();
+        const usage = { ...emptyUsage(), ...stats.tokens };
+        const name = session.model === undefined ? undefined : `${session.model.provider}/${session.model.id}`;
+        const ms = Date.now() - started;
+        recorder.usage(request.name, usage, ms, {
+            turns: stats.assistantMessages,
+            toolCalls: stats.toolCalls,
+            model: name,
+            session: stats.sessionId,
+            costUsd: stats.cost,
+        });
+        return {
+            text: (session.getLastAssistantText() ?? "").trim(),
+            usage,
+            turns: stats.assistantMessages,
+            toolCalls: stats.toolCalls,
+            ms,
+            costUsd: stats.cost,
+            model: name,
+            sessionId: stats.sessionId,
+            structured,
+        };
     }
     finally {
         clearTimeout(timer);
+        release();
+        unsubscribe();
+        session.dispose();
     }
-    if (controller.signal.aborted) {
-        throw late();
+}
+async function findModel(modelRuntime, name) {
+    const slash = name.indexOf("/");
+    if (slash <= 0) {
+        throw new Error(`The model ${name} is not in the form provider/model.`);
     }
-    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,
-    };
+    const found = modelRuntime.getModel(name.slice(0, slash), name.slice(slash + 1));
+    if (found === undefined) {
+        throw new Error(`The model ${name} is not known to pi.`);
+    }
+    return found;
 }
-function main(models) {
-    let name;
-    let output = -1;
-    for (const [id, entry] of Object.entries(models)) {
-        if (entry.outputTokens > output) {
-            output = entry.outputTokens;
-            name = id;
-        }
+function observe(log, event) {
+    if (event.type === "tool_execution_start") {
+        log.event("tool", toolFields(event.toolName, event.args));
+    }
+    else if (event.type === "tool_execution_end" && event.isError) {
+        log.event("tool.error", { tool: event.toolName }, "quiet");
+    }
+    else if (event.type === "message_update" &&
+        event.assistantMessageEvent.type === "text_delta" &&
+        log.level === "verbose") {
+        process.stderr.write(event.assistantMessageEvent.delta);
     }
-    return name;
 }
 export function toolFields(name, input) {
-    if (name !== "Bash" || typeof input !== "object" || input === null) {
+    if (name !== "bash" || typeof input !== "object" || input === null) {
         return { tool: name };
     }
     const { command } = input;
     return typeof command === "string" ? { tool: name, command } : { tool: name };
 }
-export function withStderr(error, stderr) {
-    const tail = stderr.trim();
-    if (tail.length === 0 || !(error instanceof Error)) {
-        return error;
-    }
-    return new Error(`${error.message}\nClaude CLI stderr:\n${tail}`, { cause: error });
-}
-export function spawnClaude(options, onStderr = () => undefined) {
-    const child = spawn(options.command, options.args, {
-        cwd: options.cwd,
-        env: options.env,
-        signal: options.signal,
-        detached: true,
-        stdio: ["pipe", "pipe", "pipe"],
-    });
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", onStderr);
-    track(child);
-    return child;
-}

package/dist/exec.mjs

@@ -3,7 +3,16 @@ let observer;
 let defaultTimeoutMs = 10 * 60_000;
 const STDERR_TAIL = 200_000;
 const groups = new Set();
+const stoppers = new Set();
+export function onStop(stopper) {
+    stoppers.add(stopper);
+    return () => stoppers.delete(stopper);
+}
 export function stopChildren(signal) {
+    for (const stopper of stoppers) {
+        stopper();
+    }
+    stoppers.clear();
     for (const pid of groups) {
         try {
             process.kill(-pid, signal);

package/dist/prompts.mjs

@@ -60,7 +60,7 @@ export function reviewPrompt(issue, comments, diff, earlier) {
         "The harness discards each change that you make, so a change is only lost work.",
         scope,
         "Mark a finding blocking only for a wrong result, a missing part of the issue, a regression or a broken convention.",
-        "Give the result as the structured output: a short summary and one entry per finding. The findings decide the outcome, so a problem that you leave out counts as no problem.",
+        "Give the result with the submit_result tool: a short summary and one entry per finding. The findings decide the outcome, so a problem that you leave out counts as no problem.",
     ].join("\n\n");
 }
 const UNRELATED_RULE = [

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "next-issue",
-  "version": "1.1.0",
-  "description": "Autonomous issue harness driven by the Claude Agent SDK",
+  "version": "2.0.0",
+  "description": "Autonomous issue harness driven by the pi SDK",
   "keywords": [
     "github",
     "issues",
     "agent",
-    "claude",
+    "pi",
     "automation",
     "cli"
   ],
@@ -37,10 +37,12 @@
     "prepublishOnly": "npm run typecheck && npm test"
   },
   "devDependencies": {
+    "@earendil-works/pi-ai": "^1.5.0",
     "@types/node": "^26.6.6",
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.316"
+    "@earendil-works/pi-coding-agent": "^1.5.0",
+    "typebox": "^1.4.3"
   }
 }