next-issue 2.10.0 → 2.11.0

package/README.md

@@ -461,12 +461,25 @@ to it. The worker:
   file. It works on macOS and Linux;
 - holds `next-issue.lock` in the same folder, with its process id, so only one
   worker runs. A lock whose process is no longer alive is taken over;
+- keeps the repositories it knows in `next-issue.roots.json` in the same
+  folder, so it still knows them after a restart;
 - runs at most one run per repository, and runs in several repositories at
   once. Each run is like `next-issue` without `--watch`, and the client says
   whether it merges;
 - sends every client the progress of every run when it connects and on every
   change: the issue, the step, the tool count, the last tool and the handled
   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
+  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
+  `{ "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;
 - stays when all clients close;

package/dist/github.mjs

@@ -80,7 +80,7 @@ export async function threadComments(repo, number) {
         '--paginate',
         `repos/${slug(repo)}/issues/${number}/comments`,
         '--jq',
-        '.[] | [.user.login, .body] | @json',
+        '.[] | [.user.login, .body, .html_url] | @json',
     ], { cwd: repo.root });
     return raw
         .split('\n')
@@ -93,8 +93,8 @@ export async function threadComments(repo, number) {
         catch {
             throw new Error(`gh gave a comment of #${number} that is not valid JSON: ${line}`);
         }
-        const [author, body] = parsed;
-        return { author, body: body ?? '' };
+        const [author, body, url] = parsed;
+        return url === undefined ? { author, body: body ?? '' } : { author, body: body ?? '', url };
     });
 }
 export async function canWrite(repo, login) {

package/dist/handover.mjs

@@ -1,24 +1,47 @@
 import { setStatus } from './job.mjs';
 import { message } from './observe.mjs';
-import { dropState, writeState } from './state.mjs';
+import { dropState, readState, writeState } from './state.mjs';
 export const HAND_OVER = 'next-issue needs help:';
-export async function handOverReply(context, issue, pr) {
-    const { repo, ports } = context;
-    const comments = await ports.threadComments(repo, pr ?? issue);
+function writers(repo, ports) {
     const access = new Map();
-    const writer = async (author) => {
+    return (author) => {
         if (!access.has(author)) {
-            access.set(author, await ports.canWrite(repo, author));
+            access.set(author, ports.canWrite(repo, author));
         }
-        return access.get(author) === true;
+        return access.get(author);
     };
-    let last = -1;
-    for (let index = comments.length - 1; index >= 0 && last === -1; index -= 1) {
+}
+async function lastHandOver(comments, writer) {
+    for (let index = comments.length - 1; index >= 0; index -= 1) {
         const comment = comments[index];
         if (comment.body.startsWith(HAND_OVER) && (await writer(comment.author))) {
-            last = index;
+            return index;
         }
     }
+    return -1;
+}
+export async function waitingQuestions(repo, config, ports) {
+    const writer = writers(repo, ports);
+    const issues = await ports.openIssues(repo, config.issueLimit, [config.labels.needsHuman]);
+    const questions = [];
+    for (const issue of issues) {
+        const pr = (await readState(repo, issue.number))?.pr;
+        const comments = await ports.threadComments(repo, pr ?? issue.number);
+        const comment = comments[await lastHandOver(comments, writer)];
+        questions.push({
+            issue: issue.number,
+            title: issue.title,
+            reason: comment?.body.slice(HAND_OVER.length).trim() ?? '',
+            url: comment?.url ?? '',
+        });
+    }
+    return questions;
+}
+export async function handOverReply(context, issue, pr) {
+    const { repo, ports } = context;
+    const comments = await ports.threadComments(repo, pr ?? issue);
+    const writer = writers(repo, ports);
+    const last = await lastHandOver(comments, writer);
     if (last === -1) {
         return [];
     }

package/dist/serve.mjs

@@ -5,16 +5,21 @@ import { join } from 'node:path';
 import { getAgentDir } from '@earendil-works/pi-coding-agent';
 import { WebSocketServer } from 'ws';
 import { parseArgs } from './args.mjs';
+import { loadConfig } from './config.mjs';
 import { stopChildren } from './exec.mjs';
+import { detectRepo } from './git.mjs';
+import { waitingQuestions } from './handover.mjs';
 import { message } from './observe.mjs';
 import { applyEvent, startProgress } from './progress.mjs';
-import { isNewer } from './protocol.mjs';
+import { PORTS } from './ports.mjs';
+import { isNewer, } from './protocol.mjs';
 import { runRepo } from './run.mjs';
 import { packageVersion } from './version.mjs';
 export function socketPaths(agentDir = getAgentDir()) {
     return {
         socketPath: join(agentDir, 'next-issue.sock'),
         lockPath: join(agentDir, 'next-issue.lock'),
+        rootsPath: join(agentDir, 'next-issue.roots.json'),
     };
 }
 function alive(pid) {
@@ -55,12 +60,39 @@ async function lock(path) {
     }
     return false;
 }
+async function readRoots(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        return new Set(Array.isArray(value) ? value.filter((root) => typeof root === 'string') : []);
+    }
+    catch {
+        return new Set();
+    }
+}
+export async function listQuestions(root) {
+    const config = await loadConfig(root);
+    return waitingQuestions(await detectRepo(root, config.remote), config, PORTS);
+}
 export async function startWorker(options) {
     if (!(await lock(options.lockPath))) {
         return undefined;
     }
     await rm(options.socketPath, { force: true });
     const runs = new Map();
+    const roots = await readRoots(options.rootsPath);
+    let saving = Promise.resolve();
+    const remember = (root) => {
+        if (roots.has(root)) {
+            return;
+        }
+        roots.add(root);
+        const value = `${JSON.stringify([...roots], null, 2)}\n`;
+        saving = saving
+            .then(() => writeFile(options.rootsPath, value, { mode: 0o600 }))
+            .catch(() => undefined);
+    };
+    const reads = new Map();
+    const delivered = new WeakMap();
     let restart = false;
     let finish = () => undefined;
     const closed = new Promise((resolve) => {
@@ -81,6 +113,26 @@ export async function startWorker(options) {
             send(socket, value);
         }
     };
+    const sendQuestions = async (root, targets) => {
+        remember(root);
+        const read = (reads.get(root) ?? 0) + 1;
+        reads.set(root, read);
+        let value;
+        try {
+            value = { type: 'questions', root, questions: await options.questions(root) };
+        }
+        catch (error) {
+            value = { type: 'questions-error', root, message: message(error) };
+        }
+        for (const socket of targets()) {
+            const seen = delivered.get(socket) ?? new Map();
+            if ((seen.get(root) ?? 0) < read) {
+                seen.set(root, read);
+                delivered.set(socket, seen);
+                send(socket, value);
+            }
+        }
+    };
     const busy = () => [...runs.values()].some((run) => run.progress.status === 'running' || run.progress.status === 'stopping');
     const close = async () => {
         for (const socket of sockets.clients) {
@@ -89,6 +141,7 @@ export async function startWorker(options) {
         await new Promise((resolve) => sockets.close(() => resolve()));
         await new Promise((resolve) => server.close(() => resolve()));
         await rm(options.socketPath, { force: true });
+        await saving;
         await rm(options.lockPath, { force: true });
         finish();
     };
@@ -109,6 +162,7 @@ export async function startWorker(options) {
         }
         const run = { progress: startProgress(), stop: false };
         runs.set(root, run);
+        remember(root);
         const interrupts = {
             afterIssue: () => run.stop,
             afterRound: () => run.stop,
@@ -132,7 +186,12 @@ export async function startWorker(options) {
         options
             .runRepo(root, { ...parseArgs([]), merge }, {
             interrupts,
-            onEvent: (record) => update(applyEvent(run.progress, record)),
+            onEvent: (record) => {
+                update(applyEvent(run.progress, record));
+                if (record['kind'] === 'issue.end' || record['kind'] === 'issue.error') {
+                    void sendQuestions(root, () => sockets.clients);
+                }
+            },
         })
             .then(() => {
             const status = run.stop
@@ -157,6 +216,9 @@ export async function startWorker(options) {
     sockets.on('connection', (socket) => {
         send(socket, { type: 'hello', version: options.version });
         send(socket, snapshot());
+        for (const root of roots) {
+            void sendQuestions(root, () => [socket]);
+        }
         socket.on('message', (data) => {
             let value;
             try {
@@ -177,6 +239,9 @@ export async function startWorker(options) {
             else if (value.type === 'stop') {
                 stop(value.root);
             }
+            else if (value.type === 'questions') {
+                void sendQuestions(value.root, () => [socket]);
+            }
         });
     });
     await new Promise((resolve, reject) => {
@@ -200,6 +265,7 @@ export async function serve() {
         ...paths,
         version: await packageVersion(),
         runRepo,
+        questions: listQuestions,
     });
     if (worker === undefined) {
         process.stderr.write('next-issue: another worker is running\n');

package/package.json

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