next-issue 0.3.0 → 0.5.0

package/README.md

@@ -4,13 +4,13 @@ A small harness that works through the open issues of a GitHub repository with
 the Claude Agent SDK. Run it inside a git repository.
 
 ```bash
-npx next-issue
+npx -y next-issue@latest
 ```
 
 Or install it once:
 
 ```bash
-npm install -g next-issue
+npm install -g next-issue@latest
 next-issue
 ```
 
@@ -24,7 +24,8 @@ For each open issue, oldest first:
    the claim. An issue with saved state under `.next-issue/` resumes instead,
    whatever its labels, unless another person is now the assignee.
 2. Assign the issue to you and add `status:in-progress`.
-3. Add a git worktree on a new `issue-<n>` branch from the default branch.
+3. Fetch the default branch, fast-forward the local copy of it when that is
+   safe, then add a git worktree on a new `issue-<n>` branch from it.
 4. Let the implementer agent do the work, then commit and push.
 5. Open a draft pull request that closes the issue.
 6. Wait for the checks. A pending state waits again, up to
@@ -85,13 +86,15 @@ 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.
 
-The summary also goes to standard output, so the harness fits in a pipe. 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.
 
 Recorded for each step: `claim`, `comments`, `worktree`, `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. Each agent call adds a `usage` event with the
+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` 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.
@@ -121,7 +124,7 @@ Three levels of console output:
 To write the file with the defaults, run the `init` command in the repository:
 
 ```bash
-npx next-issue init
+npx -y next-issue@latest init
 ```
 
 The command writes `next-issue.config.json` in the root of the repository and
@@ -194,6 +197,7 @@ A role without an entry in `models` uses the default model of the SDK. A
 | `--once` | Stop after the first handled issue |
 | `--max <n>` | Handle at most n issues |
 | `--reset` | Drop the saved budgets and findings first |
+| `--json` | Print the machine summary instead of the text one |
 | `--verbose` | Show every command and all agent output |
 | `--quiet` | Show only the milestones and the summary |
 | `--help` | Show the option list |
@@ -209,3 +213,19 @@ npm run build
 
 `npm run build` compiles `src/*.mts` to `dist/*.mjs`. The package holds the
 compiled files, because Node does not strip types under `node_modules`.
+
+## Releases
+
+Releases are automatic and need no pull request. Push a
+[conventional commit](https://www.conventionalcommits.org/) to `main`. The
+workflow reads the commits since the last tag and picks the bump: `feat` gives a
+minor, `fix` gives a patch, and a `!` mark or a `BREAKING CHANGE` body gives a
+major. Any other type releases nothing.
+
+The workflow then bumps the version and publishes the package to npm with a
+[trusted publish](https://docs.npmjs.com/trusted-publishers), so no token is
+stored. Only after the publish does it push the tag and make the GitHub release,
+so a failed publish leaves no half-release behind. A manual run of the workflow
+publishes the version in `package.json` and changes nothing else, which repairs
+a release that reached GitHub but not npm. The release job stays on a
+GitHub runner, because npm takes provenance only from a GitHub runner.

package/dist/agents.mjs

@@ -44,7 +44,7 @@ export async function runAgent(recorder, request) {
                 if (block.type === "tool_use") {
                     toolCalls += 1;
                     toolNames.set(block.id, block.name);
-                    log.event("tool", { tool: block.name });
+                    log.event("tool", toolFields(block.name, block.input));
                 }
                 if (block.type === "text") {
                     text += block.text;
@@ -120,3 +120,10 @@ function main(models) {
     }
     return name;
 }
+export function toolFields(name, input) {
+    if (name !== "Bash" || typeof input !== "object" || input === null) {
+        return { tool: name };
+    }
+    const { command } = input;
+    return typeof command === "string" ? { tool: name, command } : { tool: name };
+}

package/dist/cli.mjs

@@ -8,6 +8,7 @@ import { currentLogin, defaultBranch, openIssues } from "./github.mjs";
 import { message, Recorder } from "./observe.mjs";
 import { processIssue } from "./pipeline.mjs";
 import { clearState, STATE_DIR } from "./state.mjs";
+import { formatSummary } from "./summary.mjs";
 const USAGE = `next-issue [command] [options]
 
   init         write ${CONFIG_FILE} with the defaults
@@ -16,6 +17,7 @@ const USAGE = `next-issue [command] [options]
   --once       stop after the first handled issue
   --max <n>    handle at most n issues
   --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
   --verbose    show every command and all agent output
   --quiet      show only the milestones and the summary
@@ -26,6 +28,7 @@ function parseArgs(argv) {
         command: "run",
         once: false,
         help: false,
+        json: false,
         reset: false,
         force: false,
         level: "normal",
@@ -41,6 +44,9 @@ function parseArgs(argv) {
         else if (arg === "--force") {
             args.force = true;
         }
+        else if (arg === "--json") {
+            args.json = true;
+        }
         else if (arg === "--help") {
             args.help = true;
         }
@@ -147,7 +153,7 @@ async function handle(args, config, repo, recorder) {
     }, "quiet");
     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, `${JSON.stringify(summary, null, 2)}\n`);
+    await write(process.stdout, args.json ? `${JSON.stringify(summary, null, 2)}\n` : formatSummary(summary));
     return count(reports, "needs-human") + count(reports, "error") > 0 ? 1 : 0;
 }
 function count(reports, outcome) {

package/dist/git.mjs

@@ -31,6 +31,7 @@ export async function addWorktree(repo, issue, base, remote) {
     const path = worktreePath(repo, issue);
     const branch = branchName(issue);
     await must("git", ["fetch", remote, base], { cwd: repo.root });
+    await updateBase(repo, base, remote);
     await must("git", ["worktree", "prune"], { cwd: repo.root });
     if (await hasWorktree(repo, path)) {
         return path;
@@ -42,6 +43,15 @@ export async function addWorktree(repo, issue, base, remote) {
     await must("git", args, { cwd: repo.root });
     return path;
 }
+export async function updateBase(repo, base, remote) {
+    const head = await run("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd: repo.root });
+    if (head.code === 0 && head.stdout.trim() === base) {
+        const merge = await run("git", ["merge", "--ff-only", `${remote}/${base}`], { cwd: repo.root });
+        return merge.code === 0;
+    }
+    const fetch = await run("git", ["fetch", remote, `${base}:${base}`], { cwd: repo.root });
+    return fetch.code === 0;
+}
 export async function hasWorktree(repo, path) {
     const list = await must("git", ["worktree", "list", "--porcelain"], { cwd: repo.root });
     return list.split("\n").some((line) => line.trim() === `worktree ${path}`);

package/dist/summary.mjs

@@ -0,0 +1,47 @@
+const OUTCOMES = ["done", "needs-human", "error", "skipped"];
+export function formatSummary(summary) {
+    const tally = OUTCOMES.map((outcome) => `${summary.issues.filter((report) => report.outcome === outcome).length} ${outcome}`).join(", ");
+    const lines = [`run ${summary.runId}`, `issues ${summary.issues.length}: ${tally}`];
+    for (const report of summary.issues) {
+        lines.push(`  ${issueLine(report)}`);
+    }
+    const roles = Object.entries(summary.roles)
+        .map(([role, totals]) => `${role} ${tokens(totals.total)} in ${totals.calls}`)
+        .join(", ");
+    lines.push(`tokens ${tokens(summary.total.total)}${roles.length > 0 ? ` (${roles})` : ""}`);
+    lines.push(`log ${summary.logFile}`);
+    return `${lines.join("\n")}\n`;
+}
+function issueLine(report) {
+    const parts = [`#${report.issue} ${report.outcome.padEnd(11)}`];
+    if (report.pr !== undefined) {
+        parts.push(`pr ${report.pr}`);
+    }
+    if (report.ciFixes > 0) {
+        parts.push(`ci fixes ${report.ciFixes}`);
+    }
+    if (report.reviewRounds > 0) {
+        parts.push(`reviews ${report.reviewRounds}`);
+    }
+    if (report.ms > 0) {
+        parts.push(duration(report.ms));
+    }
+    if (report.reason !== undefined) {
+        parts.push(`(${report.reason})`);
+    }
+    return parts.join("  ").trimEnd();
+}
+function duration(ms) {
+    const seconds = Math.round(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    return minutes === 0 ? `${seconds}s` : `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
+}
+function tokens(value) {
+    if (value < 1000) {
+        return String(value);
+    }
+    if (value < 1_000_000) {
+        return `${(value / 1000).toFixed(1)}k`;
+    }
+    return `${(value / 1_000_000).toFixed(2)}M`;
+}

package/package.json

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