@ravshansbox/pi-next-issue 6.0.2 → 6.2.0

package/README.md

@@ -13,8 +13,12 @@ It needs `git`, `npx` and an authenticated [`gh`](https://cli.github.com/). It w
 Run this in pi, inside a git repository:
 
 - `/next-issue start [flags]` starts a run of this repository when none is going. The flags are those of the `next-issue` CLI: `--once`, `--max <n>`, `--watch`, `--hunt`, `--reset`, `--verbose` and `--quiet`. For example, `/next-issue start --hunt` hunts for bugs and keeps watching, like `next-issue --hunt`. The worker refuses any other argument, or a command such as `init`, and a note says why. When a run is going, a note says so, and nothing starts or restarts.
-- `/next-issue stop` stops the run of this repository. A stop takes effect after the current round, and the issue keeps its saved state, so the next run resumes it. When no run is going, a note says so.
-- `/next-issue` with no argument shows the usage: `start [flags]`, `stop` and `answer`. Pi suggests these as you type after `/next-issue `.
+- `/next-issue stop [--after issue|round|now]` stops the run of this repository. When no run is going, a note says so. An unknown value or flag shows an error and stops nothing.
+  - `--after issue`, the default: the run claims no new issue and starts no new hunt. It finishes the issues that it holds and a hunt that is going, then ends as `stopped`.
+  - `--after round`: each running issue stops after its current round and keeps its saved state, worktree and labels, so the next run resumes it. A hunt that is going ends first.
+  - `--after now`: the run stops every agent, command and hunt at once. The worker keeps running.
+  - A stop with a later point than one already asked for changes nothing. A stop with an earlier point replaces it.
+- `/next-issue` with no argument shows the usage: `start [flags]`, `stop [--after issue|round|now]` and `answer`. Pi suggests these as you type after `/next-issue `. After `/next-issue start `, pi suggests the flags that are not typed yet, each with a short description.
 - The `next_issue_start` tool lets the model start a run. It takes an optional `args` array with the same flags as `/next-issue start`. When no run is going, it starts a run like `/next-issue start`. When a run is going, it starts nothing and reports the current run, which picks up new issues by itself. It never stops a run, and it does not ask for confirmation. Its result says whether it started a run.
 - The `next_issue_status` tool lets the model see the run of this repository. It returns the footer line, then one line per handled issue with its outcome, for example `#190 done`. When the worker has no run of this repository, it returns `no run of <root>`. When no worker is going, it returns `no worker is running` and does not start one. It reports no other repository.
 

package/index.ts

@@ -8,7 +8,7 @@ import { errorText } from './src/errors.ts';
 import { must } from './src/exec.ts';
 import { repoRoot } from './src/git.ts';
 import type { Progress, Question } from './src/protocol.ts';
-import { requestStart, requestStop, startRun, statusOf } from './src/run.ts';
+import { parseStopArgs, requestStart, requestStop, startRun, statusOf } from './src/run.ts';
 import {
   type Action,
   cannotNote,
@@ -33,13 +33,59 @@ const QUESTIONS_KEY = 'next-issue-questions';
 const RENDER_MS = 1000;
 const QUESTIONS_MS = 60_000;
 const SUBCOMMANDS: Action[] = ['start', 'stop', 'answer'];
-const FLAGS = '--once, --max <n>, --watch, --hunt, --reset, --verbose, --quiet';
+const START_FLAGS = [
+  { flag: '--once', insert: '--once', description: 'Stop after the first handled issue' },
+  { flag: '--max', insert: '--max ', argument: '<n>', description: 'Handle at most n issues' },
+  {
+    flag: '--watch',
+    insert: '--watch',
+    description: 'Keep running, and read the open issues again after each pass',
+  },
+  {
+    flag: '--hunt',
+    insert: '--hunt',
+    description: 'Hunt the repository for bugs alongside the issues',
+  },
+  {
+    flag: '--reset',
+    insert: '--reset',
+    description: 'Drop the saved budgets and findings, and keep the rest of the state',
+  },
+  {
+    flag: '--verbose',
+    insert: '--verbose',
+    description: 'Show every command and all agent output',
+  },
+  { flag: '--quiet', insert: '--quiet', description: 'Show only the milestones and the summary' },
+];
+const FLAGS = START_FLAGS.map(({ flag, argument }) =>
+  argument ? `${flag} ${argument}` : flag,
+).join(', ');
 const USAGE = [
   '/next-issue start [flags]  start a run of this repository, with flags from: ' + FLAGS,
-  '/next-issue stop           stop the run of this repository after the current round',
+  '/next-issue stop [--after issue|round|now]',
+  '                           stop the run of this repository after the running issues (issue, the default), after the current round (round), or at once (now)',
   '/next-issue answer         answer the waiting questions',
 ].join('\n');
 
+function completions(prefix: string) {
+  if (!prefix.includes(' ')) {
+    return SUBCOMMANDS.filter((name) => name.startsWith(prefix)).map((name) => ({
+      value: name,
+      label: name,
+    }));
+  }
+  if (!prefix.startsWith('start ')) {
+    return [];
+  }
+  const head = prefix.slice(0, prefix.lastIndexOf(' ') + 1);
+  const partial = prefix.slice(head.length);
+  const typed = head.split(/\s+/);
+  return START_FLAGS.filter(({ flag }) => flag.startsWith(partial) && !typed.includes(flag)).map(
+    ({ flag, insert, description }) => ({ value: head + insert, label: flag, description }),
+  );
+}
+
 function background(callback: () => void, ms: number): ReturnType<typeof setInterval> {
   const timer = setInterval(callback, ms);
   timer.unref?.();
@@ -257,10 +303,10 @@ export function createExtension(options: Options) {
     });
 
     pi.registerCommand('next-issue', {
-      description: `"start [flags]" starts working through the GitHub issues of this repository, with flags from ${FLAGS}. "stop" stops the run. "answer" answers the waiting questions`,
+      description: `"start [flags]" starts working through the GitHub issues of this repository, with flags from ${FLAGS}. "stop [--after issue|round|now]" stops the run after the running issues (the default), after the current round, or at once. "answer" answers the waiting questions`,
       getArgumentCompletions: (prefix) => {
-        const matches = SUBCOMMANDS.filter((name) => name.startsWith(prefix));
-        return matches.length === 0 ? null : matches.map((name) => ({ value: name, label: name }));
+        const matches = completions(prefix);
+        return matches.length === 0 ? null : matches;
       },
       handler: async (args, ctx) => {
         const [subcommand, ...flags] = args.trim().split(/\s+/).filter(Boolean);
@@ -274,11 +320,12 @@ export function createExtension(options: Options) {
           }
         };
         try {
+          const after = subcommand === 'stop' ? parseStopArgs(flags) : undefined;
           const { client, root, progress } = await connect(ctx);
           if (subcommand === 'answer') {
             await answerAll(ctx.ui, options.gh, client, root);
-          } else if (subcommand === 'stop') {
-            notify(requestStop(client, root, progress));
+          } else if (after !== undefined) {
+            notify(requestStop(client, root, progress, after));
           } else {
             notify(requestStart(client, root, progress, flags));
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ravshansbox/pi-next-issue",
-  "version": "6.0.2",
+  "version": "6.2.0",
   "description": "Pi extension that works through GitHub issues with the next-issue worker",
   "license": "MIT",
   "type": "module",

package/src/protocol.ts

@@ -28,10 +28,14 @@ export type Question = {
   labels: { needsHuman: string; skip: string };
 };
 
+export const STOP_POINTS = ['issue', 'round', 'now'] as const;
+
+export type StopPoint = (typeof STOP_POINTS)[number];
+
 export type ClientMessage =
   | { type: 'hello'; version: string }
   | { type: 'start'; root: string; args?: string[] }
-  | { type: 'stop'; root: string }
+  | { type: 'stop'; root: string; after?: StopPoint }
   | { type: 'questions'; root: string; id?: string };
 
 export type WorkerMessage =

package/src/run.ts

@@ -1,4 +1,4 @@
-import { going, type Progress } from './protocol.ts';
+import { going, type Progress, STOP_POINTS, type StopPoint } from './protocol.ts';
 import { accepted } from './requests.ts';
 import { formatStatus, handledNote, type Note } from './status.ts';
 import type { WorkerClient } from './worker.ts';
@@ -57,14 +57,36 @@ export function requestStart(
   return undefined;
 }
 
+export function parseStopArgs(args: string[]): StopPoint {
+  const [flag, value, ...rest] = args;
+  if (flag === undefined) {
+    return 'issue';
+  }
+  if (flag !== '--after') {
+    throw new Error(`stop does not take ${flag}`);
+  }
+  const point = STOP_POINTS.find((candidate) => candidate === value);
+  if (point === undefined) {
+    const known = 'issue, round or now';
+    throw new Error(
+      value === undefined ? `--after takes ${known}` : `--after takes ${known}, not ${value}`,
+    );
+  }
+  if (rest[0] !== undefined) {
+    throw new Error(`stop does not take ${rest[0]}`);
+  }
+  return point;
+}
+
 export function requestStop(
   client: WorkerClient,
   root: string,
   progress: Progress | undefined,
+  after: StopPoint,
 ): Note | undefined {
   if (!going(progress)) {
     return { text: `No run of ${root} is going.`, level: 'info' };
   }
-  client.send({ type: 'stop', root });
+  client.send({ type: 'stop', root, after });
   return undefined;
 }