next-issue 2.11.0 → 2.13.0

package/README.md

@@ -248,6 +248,13 @@ jq -r 'select(.kind=="usage") | [.issue,.role,.turns,.total] | @tsv' \
   .next-issue/runs/*.jsonl
 ```
 
+`next-issue logs` shows the newest run log, one readable line per event, and
+then prints new events as the run adds them, until `Ctrl-C`. In a terminal it
+starts with the last events that fit the screen; in a pipe it starts with all
+of them. It stops when the reader of the pipe closes it; on Linux it notices
+this only at the next event. With `--json` it prints the raw JSON lines. This also shows a run of
+the worker, whose progress goes to no terminal.
+
 Three levels of console output:
 
 | Level       | Shows                                                            |
@@ -408,13 +415,14 @@ state of an issue that a label still holds back stays as it was.
 | `init`      | Write the config file with the defaults                                                                                       |
 | `serve`     | Run the worker that pi extensions talk to, see [Worker](#worker)                                                              |
 | `stop`      | Stop the worker, see [Worker](#worker)                                                                                        |
+| `logs`      | Show the latest run log and follow it, see [Observability](#observability)                                                    |
 | `--force`   | Replace an existing config file, with `init`                                                                                  |
 | `--once`    | Stop after the first handled issue                                                                                            |
 | `--max <n>` | Handle at most n issues                                                                                                       |
 | `--merge`   | Squash-merge the pull request after the approval, delete the remote branch and fix a failure of the checks on the base branch |
 | `--watch`   | Keep running, and read the open issues again after each pass                                                                  |
 | `--reset`   | Drop the saved budgets and findings, and keep the rest of the state                                                           |
-| `--json`    | Print the machine summary instead of the text one                                                                             |
+| `--json`    | Print the machine summary instead of the text one, or the raw JSON lines with `logs`                                          |
 | `--verbose` | Show every command and all agent output                                                                                       |
 | `--quiet`   | Show only the milestones and the summary                                                                                      |
 | `--help`    | Show the option list                                                                                                          |
@@ -471,14 +479,17 @@ to it. The worker:
   issues;
 - sends every client a `questions` message for each repository: the open
   issues with the `needsHuman` label, each with its number, title, the reason
-  of the hand-over and the url of the comment that holds it. It reads them
+  of the hand-over, the url of the comment that holds it, the `owner/name`
+  repository, the pull request when there is one, and the `needsHuman` and
+  `skip` labels. It reads them
   from GitHub, so the list is the same after a restart. It sends them when a
   client connects, for each repository it knows, after each issue of a run
   ends, and when a client sends `{ "type": "questions", "root": "<path>" }`.
   An issue that no longer has the label leaves the list. An issue with the
   label but no hand-over comment is in the list with an empty reason and url.
   The issues are read one at a time. A client never gets an older list after
-  a newer one. When the list cannot be read, the client gets
+  a newer one. When the client adds an `"id"` to its message, the list that
+  answers it carries the same `id` and is read after the message arrived. When the list cannot be read, the client gets
   `{ "type": "questions-error", "root": "<path>", "message": "<text>" }`;
 - stops a run, when a client asks, like a second `Ctrl-C`: after the current
   round, with the state kept;

package/dist/args.mjs

@@ -4,13 +4,14 @@ export const USAGE = `next-issue [command] [options]
   init         write ${CONFIG_FILE} with the defaults
   serve        run the worker that pi extensions talk to
   stop         stop the worker
+  logs         show the latest run log and follow it
 
   --once       stop after the first handled issue
   --max <n>    handle at most n issues
   --merge      squash-merge the pull request after the approval
   --watch      keep running and read the issues again after each pass
   --reset      drop the saved budgets and findings first
-  --json       print the machine summary instead of the text one
+  --json       print the machine summary instead of the text one, or raw lines with logs
   --force      replace an existing config file, with init
   --verbose    show every command and all agent output
   --quiet      show only the milestones and the summary
@@ -31,7 +32,7 @@ export function parseArgs(argv) {
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
         if (index === 0 && !arg.startsWith('-')) {
-            if (arg !== 'init' && arg !== 'serve' && arg !== 'stop') {
+            if (arg !== 'init' && arg !== 'serve' && arg !== 'stop' && arg !== 'logs') {
                 throw new Error(`Unknown command: ${arg}`);
             }
             args.command = arg;

package/dist/cli.mjs

@@ -3,6 +3,7 @@ import { parseArgs, USAGE } from './args.mjs';
 import { writeDefaultConfig } from './config.mjs';
 import { ensureIgnored, repoRoot, WORKTREE_DIR } from './git.mjs';
 import { listenForInterrupts } from './interrupt.mjs';
+import { followLog, newestRunLog } from './logs.mjs';
 import { message } from './observe.mjs';
 import { runRepo } from './run.mjs';
 import { serve, socketPaths, stopWorker } from './serve.mjs';
@@ -33,12 +34,24 @@ async function main() {
     if (args.command === 'init') {
         return init(root, args.force);
     }
+    if (args.command === 'logs') {
+        return logs(root, args.json);
+    }
     const interrupts = listenForInterrupts((text) => void write(process.stderr, `${text}\n`));
     return runRepo(root, args, {
         interrupts,
         print: (summary) => write(process.stdout, args.json ? `${JSON.stringify(summary, null, 2)}\n` : formatSummary(summary)),
     });
 }
+async function logs(root, json) {
+    const file = await newestRunLog(root);
+    if (file === undefined) {
+        await write(process.stderr, `next-issue: no run log in ${STATE_DIR}/runs\n`);
+        return 1;
+    }
+    const tail = process.stdout.isTTY ? Math.max(1, (process.stdout.rows || 24) - 1) : undefined;
+    return followLog(file, { json, tail }, (text) => write(process.stdout, text));
+}
 async function init(root, force) {
     const path = await writeDefaultConfig(root, force);
     await write(process.stdout, `wrote ${path}\n`);

package/dist/handover.mjs

@@ -33,6 +33,9 @@ export async function waitingQuestions(repo, config, ports) {
             title: issue.title,
             reason: comment?.body.slice(HAND_OVER.length).trim() ?? '',
             url: comment?.url ?? '',
+            repo: `${repo.owner}/${repo.name}`,
+            ...(pr === undefined ? {} : { pr }),
+            labels: { needsHuman: config.labels.needsHuman, skip: config.labels.skip },
         });
     }
     return questions;

package/dist/logs.mjs

@@ -0,0 +1,99 @@
+import { writeSync } from 'node:fs';
+import { open, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { render } from './observe.mjs';
+import { STATE_DIR } from './state.mjs';
+const POLL_MS = 200;
+export async function newestRunLog(root) {
+    const dir = join(root, STATE_DIR, 'runs');
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return undefined;
+    }
+    const newest = names
+        .filter((name) => name.endsWith('.jsonl'))
+        .sort()
+        .at(-1);
+    return newest === undefined ? undefined : join(dir, newest);
+}
+export async function followLog(file, options, print) {
+    const handle = await open(file, 'r');
+    let stopped = false;
+    let wake;
+    const stop = () => {
+        stopped = true;
+        wake?.();
+    };
+    process.on('SIGINT', stop);
+    process.stdout.on('error', stop);
+    const show = (line) => {
+        if (options.json) {
+            return `${line}\n`;
+        }
+        try {
+            return render(JSON.parse(line));
+        }
+        catch {
+            return '';
+        }
+    };
+    const decoder = new StringDecoder('utf8');
+    let position = 0;
+    let rest = '';
+    let first = true;
+    try {
+        while (!stopped) {
+            const buffer = Buffer.alloc(64 * 1024);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+            if (bytesRead > 0) {
+                position += bytesRead;
+                rest += decoder.write(buffer.subarray(0, bytesRead));
+                if (bytesRead === buffer.length) {
+                    continue;
+                }
+            }
+            const lines = rest.split('\n');
+            rest = lines.pop();
+            let shown = lines.filter((line) => line.trim().length > 0);
+            if (first && options.tail !== undefined) {
+                shown = shown.slice(-options.tail);
+            }
+            first = false;
+            if (shown.length > 0) {
+                await print(shown.map(show).join(''));
+            }
+            try {
+                writeSync(process.stdout.fd, '');
+            }
+            catch {
+                stop();
+            }
+            if (stopped) {
+                break;
+            }
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, POLL_MS);
+                wake = () => {
+                    clearTimeout(timer);
+                    resolve();
+                };
+            });
+            wake = undefined;
+        }
+    }
+    catch (error) {
+        if (!stopped && error.code !== 'EPIPE') {
+            throw error;
+        }
+    }
+    finally {
+        process.off('SIGINT', stop);
+        process.stdout.off('error', stop);
+        await handle.close();
+    }
+    return 0;
+}

package/dist/observe.mjs

@@ -171,7 +171,7 @@ export async function pruneRuns(root, keepDays) {
 export function message(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function render(record) {
+export function render(record) {
     const time = new Date(String(record.ts)).toTimeString().slice(0, 8);
     const issue = record.issue === undefined ? '' : ` #${record.issue}`;
     const extras = Object.entries(record)

package/dist/serve.mjs

@@ -113,7 +113,7 @@ export async function startWorker(options) {
             send(socket, value);
         }
     };
-    const sendQuestions = async (root, targets) => {
+    const sendQuestions = async (root, targets, id) => {
         remember(root);
         const read = (reads.get(root) ?? 0) + 1;
         reads.set(root, read);
@@ -126,10 +126,14 @@ export async function startWorker(options) {
         }
         for (const socket of targets()) {
             const seen = delivered.get(socket) ?? new Map();
-            if ((seen.get(root) ?? 0) < read) {
-                seen.set(root, read);
+            const last = seen.get(root);
+            if (last === undefined || last.read < read) {
+                seen.set(root, { read, value });
                 delivered.set(socket, seen);
-                send(socket, value);
+                send(socket, id === undefined ? value : { ...value, id });
+            }
+            else if (id !== undefined) {
+                send(socket, { ...last.value, id });
             }
         }
     };
@@ -240,7 +244,7 @@ export async function startWorker(options) {
                 stop(value.root);
             }
             else if (value.type === 'questions') {
-                void sendQuestions(value.root, () => [socket]);
+                void sendQuestions(value.root, () => [socket], value.id);
             }
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-issue",
-  "version": "2.11.0",
+  "version": "2.13.0",
   "description": "Autonomous issue harness driven by the pi SDK",
   "keywords": [
     "github",