@ravshansbox/pi-next-issue 1.0.2 → 1.0.4

package/README.md

@@ -22,7 +22,7 @@ The run does not belong to a session: it goes on after `/new`, `/resume`, a fork
 
 ## What it does
 
-Each loop fetches the open issues and takes the oldest one with saved state, else the oldest one with the `status:todo` label and none of `status:in-progress`, `status:done`, `status:needs-human` or `status:blocked`. The run ends when no such issue is left, or at the first error. For each issue:
+Each loop fetches the 200 oldest open issues with the `status:todo` label and none of `status:in-progress`, `status:done`, `status:needs-human` or `status:blocked`, and the open issues with saved state that it can read. It takes the oldest one with saved state, else the oldest one with the `status:todo` label and none of `status:in-progress`, `status:done`, `status:needs-human` or `status:blocked`. The run ends when no such issue is left, or at the first error. For each issue:
 
 1. Swap `status:todo` for `status:in-progress`.
 2. Add a git worktree at `.worktrees/<n>` on the `<n>` branch, from the remote default branch.
@@ -39,7 +39,7 @@ The implementer and the reviewer read the issue title, the body and the comments
 
 Each agent is a pi session in the worktree. It uses the model and thinking level from your pi settings, and loads all of your extensions except this one.
 
-The state of each issue is saved in `.worktrees/<n>.json`. The extension adds `/.worktrees/` to `.git/info/exclude`.
+The state of each issue is saved in `.worktrees/<n>.json`. A run holds `.worktrees/run.lock`, which keeps the process id, so that only one pi at a time works on a repository. A second run fails at once. A lock whose process is no longer alive is taken over. If the operating system gives that process id to another process, the lock stays; remove `.worktrees/run.lock` by hand when no run is going. The extension adds `/.worktrees/` to `.git/info/exclude`.
 
 ## Config
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ravshansbox/pi-next-issue",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Pi extension that works through GitHub issues in the background",
   "license": "MIT",
   "type": "module",

package/src/github.ts

@@ -1,6 +1,6 @@
 import { setTimeout as sleep } from 'node:timers/promises';
 import { must, run } from './exec.ts';
-import type { ChecksResult, Issue } from './runner.ts';
+import { LABELS, STOP_LABELS, type ChecksResult, type Issue } from './runner.ts';
 
 export type Repo = { root: string; slug: string };
 
@@ -28,25 +28,48 @@ export async function defaultBranch(repo: Repo): Promise<string> {
   );
 }
 
-export async function openIssues(repo: Repo): Promise<Issue[]> {
+type RawIssue = {
+  number: number;
+  title: string;
+  body: string | null;
+  createdAt: string;
+  labels: Array<{ name: string }>;
+};
+
+const ISSUE_FIELDS = 'number,title,body,labels,createdAt';
+
+export async function openIssues(repo: Repo, saved: number[]): Promise<Issue[]> {
   const raw = await gh(repo, [
     'issue',
     'list',
     '--state',
     'open',
+    '--label',
+    LABELS.ready,
+    '--search',
+    ['sort:created-asc', ...STOP_LABELS.map((label) => `-label:${label}`)].join(' '),
     '--limit',
     '200',
     '--json',
-    'number,title,body,labels,createdAt',
+    ISSUE_FIELDS,
   ]);
-  const parsed = JSON.parse(raw) as Array<{
-    number: number;
-    title: string;
-    body: string | null;
-    createdAt: string;
-    labels: Array<{ name: string }>;
-  }>;
-  return parsed
+  const listed = JSON.parse(raw) as RawIssue[];
+  const known = new Set(listed.map((item) => item.number));
+  for (const number of saved.filter((item) => !known.has(item))) {
+    const view = await run(
+      'gh',
+      ['issue', 'view', String(number), '--json', `${ISSUE_FIELDS},state`, '--repo', repo.slug],
+      { cwd: repo.root },
+    );
+    if (view.code !== 0) {
+      continue;
+    }
+    const item = JSON.parse(view.stdout) as RawIssue & { state: string };
+    if (item.state === 'OPEN') {
+      listed.push(item);
+    }
+  }
+  return listed
     .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
     .map((item) => ({
       number: item.number,

package/src/ports.ts

@@ -10,7 +10,7 @@ export async function createPorts(root: string, config: Config): Promise<Ports>
   const base = await github.defaultBranch(repo);
   const timeoutMs = config.checkTimeoutMinutes * 60_000;
   return {
-    openIssues: () => github.openIssues(repo),
+    openIssues: async () => github.openIssues(repo, await state.savedIssues(root)),
     comments: (issue) => github.comments(repo, issue),
     setLabel: (issue, add, remove) => github.setLabel(repo, issue, add, remove),
     commentOnIssue: (issue, body) => github.commentOnIssue(repo, issue, body),
@@ -32,5 +32,7 @@ export async function createPorts(root: string, config: Config): Promise<Ports>
     writeState: (value) => state.writeState(root, value),
     dropState: (issue) => state.dropState(root, issue),
     savedIssues: () => state.savedIssues(root),
+    lock: () => state.lock(root),
+    unlock: () => state.unlock(root),
   };
 }

package/src/runner.ts

@@ -60,6 +60,8 @@ export type Ports = {
   writeState(state: IssueState): Promise<void>;
   dropState(issue: number): Promise<void>;
   savedIssues(): Promise<number[]>;
+  lock(): Promise<void>;
+  unlock(): Promise<void>;
 };
 
 export type Outcome = 'merged' | 'needs-human';
@@ -86,7 +88,7 @@ export const LABELS = {
   blocked: 'status:blocked',
 };
 
-const STOP_LABELS = [LABELS.inProgress, LABELS.done, LABELS.needsHuman, LABELS.blocked];
+export const STOP_LABELS = [LABELS.inProgress, LABELS.done, LABELS.needsHuman, LABELS.blocked];
 
 function ready(issue: Issue): boolean {
   return (
@@ -123,7 +125,10 @@ export class Runner {
   async run(): Promise<void> {
     this.update({ status: 'running' });
     const seen = new Set<number>();
+    let locked = false;
     try {
+      await this.ports.lock();
+      locked = true;
       for (;;) {
         this.controller.signal.throwIfAborted();
         const issues = await this.ports.openIssues();
@@ -148,6 +153,10 @@ export class Runner {
           error: error instanceof Error ? error.message : String(error),
         });
       }
+    } finally {
+      if (locked) {
+        await this.ports.unlock().catch(() => {});
+      }
     }
   }
 

package/src/state.ts

@@ -1,4 +1,4 @@
-import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { link, mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { WORKTREE_DIR } from './git.ts';
 import type { IssueState } from './runner.ts';
@@ -38,3 +38,84 @@ export async function savedIssues(root: string): Promise<number[]> {
     return match === null ? [] : [Number(match[1])];
   });
 }
+
+function lockFile(root: string): string {
+  return join(dir(root), 'run.lock');
+}
+
+function alive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'EPERM';
+  }
+}
+
+async function holder(path: string): Promise<number> {
+  return Number((await readFile(path, 'utf8').catch(() => '')).trim());
+}
+
+function busy(pid: number, cause: unknown): Error {
+  return new Error(`another run works on this repository (pid ${pid})`, { cause });
+}
+
+async function place(root: string): Promise<void> {
+  const draft = `${lockFile(root)}.${process.pid}.draft`;
+  await writeFile(draft, `${process.pid}\n`);
+  try {
+    await link(draft, lockFile(root));
+  } finally {
+    await rm(draft, { force: true });
+  }
+}
+
+async function claim(root: string): Promise<void> {
+  try {
+    await place(root);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'EEXIST') {
+      throw busy(await holder(lockFile(root)), error);
+    }
+    throw error;
+  }
+}
+
+export async function lock(root: string): Promise<void> {
+  await mkdir(dir(root), { recursive: true });
+  try {
+    await place(root);
+    return;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
+      throw error;
+    }
+    const pid = await holder(lockFile(root));
+    if (Number.isInteger(pid) && pid > 0 && alive(pid)) {
+      throw busy(pid, error);
+    }
+    const stale = `${lockFile(root)}.${process.pid}`;
+    try {
+      await rename(lockFile(root), stale);
+    } catch (renameError) {
+      if ((renameError as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw renameError;
+      }
+      return claim(root);
+    }
+    const moved = await holder(stale);
+    if (!Object.is(moved, pid)) {
+      await link(stale, lockFile(root)).catch(() => undefined);
+      await rm(stale, { force: true });
+      throw busy(moved, error);
+    }
+    await rm(stale, { force: true });
+  }
+  await claim(root);
+}
+
+export async function unlock(root: string): Promise<void> {
+  if ((await holder(lockFile(root))) === process.pid) {
+    await rm(lockFile(root), { force: true });
+  }
+}