@ravshansbox/pi-next-issue 1.2.0 → 2.3.0

package/src/worker.ts

@@ -0,0 +1,241 @@
+import { spawn } from 'node:child_process';
+import { closeSync, openSync } from 'node:fs';
+import { join } from 'node:path';
+import WebSocket from 'ws';
+
+export type RunStatus = 'running' | 'stopping' | 'finished' | 'stopped' | 'failed';
+
+export type Handled = { issue: number; outcome: 'done' | 'needs-human' | 'error' };
+
+export type Progress = {
+  status: RunStatus;
+  issue?: number;
+  title?: string;
+  stage?: string;
+  tools: number;
+  lastTool?: string;
+  issueStartedAt?: number;
+  handled: Handled[];
+  error?: string;
+};
+
+export type ClientMessage =
+  | { type: 'hello'; version: string }
+  | { type: 'start'; root: string; merge: boolean }
+  | { type: 'stop'; root: string };
+
+export type WorkerMessage =
+  | { type: 'hello'; version: string }
+  | { type: 'runs'; runs: Record<string, Progress> }
+  | { type: 'error'; root: string; message: string };
+
+export type WorkerEvent =
+  | { type: 'runs'; runs: Record<string, Progress> }
+  | { type: 'error'; root: string; message: string };
+
+export type WorkerOptions = {
+  socketPath: string;
+  version: string;
+  spawnWorker: () => void;
+  startTimeoutMs?: number;
+  reconnectMs?: number;
+};
+
+const START_TIMEOUT_MS = 120_000;
+const RECONNECT_MS = 5_000;
+const POLL_MS = 200;
+
+export function isNewer(candidate: string, current: string): boolean {
+  const left = candidate.split('.').map(Number);
+  const right = current.split('.').map(Number);
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference !== 0) {
+      return difference > 0;
+    }
+  }
+  return false;
+}
+
+export function spawnWorker(agentDir: string): void {
+  const log = openSync(join(agentDir, 'next-issue-worker.log'), 'a');
+  try {
+    const child = spawn('npx', ['-y', 'next-issue@latest', 'serve'], {
+      detached: true,
+      stdio: ['ignore', log, log],
+    });
+    child.on('error', () => {});
+    child.unref();
+  } finally {
+    closeSync(log);
+  }
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms).unref?.());
+}
+
+export class WorkerClient {
+  runs: Record<string, Progress> = {};
+  private socket: WebSocket | undefined;
+  private workerVersion: string | undefined;
+  private connecting: Promise<void> | undefined;
+  private reconnectTimer: ReturnType<typeof setTimeout> | undefined;
+  private readonly listeners = new Set<(event: WorkerEvent) => void>();
+  private readonly options: WorkerOptions;
+
+  constructor(options: WorkerOptions) {
+    this.options = options;
+  }
+
+  get connected(): boolean {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+
+  subscribe(listener: (event: WorkerEvent) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  send(message: ClientMessage): void {
+    this.socket?.send(JSON.stringify(message));
+  }
+
+  async attach(): Promise<void> {
+    if (this.connected) {
+      return;
+    }
+    await this.open().catch(() => this.scheduleReconnect());
+  }
+
+  async ensure(): Promise<void> {
+    if (!this.connected) {
+      this.connecting ??= this.start().finally(() => {
+        this.connecting = undefined;
+      });
+      await this.connecting;
+    }
+    if (this.workerVersion !== undefined && isNewer(this.options.version, this.workerVersion)) {
+      const busy = Object.values(this.runs).some(
+        (run) => run.status === 'running' || run.status === 'stopping',
+      );
+      if (!busy) {
+        await this.waitForClose();
+        this.connecting ??= this.start().finally(() => {
+          this.connecting = undefined;
+        });
+        await this.connecting;
+      }
+    }
+  }
+
+  close(): void {
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = undefined;
+    this.listeners.clear();
+    const socket = this.socket;
+    this.socket = undefined;
+    socket?.terminate();
+  }
+
+  private async start(): Promise<void> {
+    try {
+      await this.open();
+      return;
+    } catch {
+      this.options.spawnWorker();
+    }
+    const deadline = Date.now() + (this.options.startTimeoutMs ?? START_TIMEOUT_MS);
+    for (;;) {
+      await delay(POLL_MS);
+      try {
+        await this.open();
+        return;
+      } catch (error) {
+        if (Date.now() >= deadline) {
+          throw new Error(
+            `the next-issue worker did not start: ${error instanceof Error ? error.message : String(error)}`,
+          );
+        }
+      }
+    }
+  }
+
+  private open(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const socket = new WebSocket(`ws+unix://${this.options.socketPath}:/`);
+      let hello = false;
+      socket.once('error', (error) => {
+        if (!hello) {
+          reject(error);
+        }
+      });
+      socket.on('message', (data) => {
+        let message: WorkerMessage;
+        try {
+          message = JSON.parse(String(data)) as WorkerMessage;
+        } catch {
+          return;
+        }
+        if (message.type === 'hello') {
+          this.workerVersion = message.version;
+        } else if (message.type === 'runs') {
+          this.runs = message.runs;
+          this.emit({ type: 'runs', runs: message.runs });
+          if (!hello) {
+            hello = true;
+            resolve();
+          }
+        } else if (message.type === 'error') {
+          this.emit(message);
+        }
+      });
+      socket.once('open', () => {
+        this.socket = socket;
+        socket.send(JSON.stringify({ type: 'hello', version: this.options.version }));
+      });
+      socket.once('close', () => {
+        if (this.socket === socket) {
+          this.socket = undefined;
+          this.scheduleReconnect();
+        }
+        if (!hello) {
+          reject(new Error('the worker closed the connection'));
+        }
+      });
+    });
+  }
+
+  private waitForClose(): Promise<void> {
+    const socket = this.socket;
+    if (socket === undefined || socket.readyState === WebSocket.CLOSED) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const timer = setTimeout(resolve, this.options.startTimeoutMs ?? START_TIMEOUT_MS);
+      socket.once('close', () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+
+  private scheduleReconnect(): void {
+    if (this.listeners.size === 0 || this.reconnectTimer !== undefined) {
+      return;
+    }
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = undefined;
+      if (!this.connected && this.connecting === undefined) {
+        void this.attach();
+      }
+    }, this.options.reconnectMs ?? RECONNECT_MS);
+    this.reconnectTimer.unref?.();
+  }
+
+  private emit(event: WorkerEvent): void {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+}

package/src/agent.ts

@@ -1,105 +0,0 @@
-import { dirname, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import {
-  createAgentSession,
-  DefaultResourceLoader,
-  defineTool,
-  getAgentDir,
-  SessionManager,
-  type ToolDefinition,
-} from '@earendil-works/pi-coding-agent';
-import { Type } from 'typebox';
-import type { AgentTask, Verdict } from './runner.ts';
-
-const PACKAGE_DIR = dirname(dirname(fileURLToPath(import.meta.url)));
-
-export function isOwnExtension(path: string): boolean {
-  return path === PACKAGE_DIR || path.startsWith(PACKAGE_DIR + sep);
-}
-
-export function toolLabel(name: string, args: unknown): string {
-  const fields = (typeof args === 'object' && args !== null ? args : {}) as Record<string, unknown>;
-  const detail = [fields['command'], fields['path'], fields['file_path'], fields['pattern']].find(
-    (value) => typeof value === 'string',
-  ) as string | undefined;
-  const line = detail === undefined ? name : `${name} ${detail.split('\n')[0]}`;
-  return line.length > 80 ? `${line.slice(0, 79)}…` : line;
-}
-
-async function runSession(task: AgentTask, customTools: ToolDefinition[]): Promise<string> {
-  const agentDir = getAgentDir();
-  const resourceLoader = new DefaultResourceLoader({
-    cwd: task.cwd,
-    agentDir,
-    extensionsOverride: (base) => ({
-      ...base,
-      extensions: base.extensions.filter((extension) => !isOwnExtension(extension.resolvedPath)),
-    }),
-  });
-  await resourceLoader.reload();
-  const { session } = await createAgentSession({
-    cwd: task.cwd,
-    agentDir,
-    resourceLoader,
-    sessionManager: SessionManager.inMemory(task.cwd),
-    customTools,
-  });
-  const abort = () => void session.abort();
-  task.signal.addEventListener('abort', abort);
-  const unsubscribe = session.subscribe((event) => {
-    if (event.type === 'tool_execution_start') {
-      task.onTool(toolLabel(event.toolName, event.args));
-    }
-  });
-  try {
-    await session.bindExtensions({});
-    task.signal.throwIfAborted();
-    await session.prompt(task.prompt, { expandPromptTemplates: false });
-    task.signal.throwIfAborted();
-    const last = session.messages.findLast((message) => message.role === 'assistant');
-    if (last !== undefined && 'stopReason' in last && last.stopReason === 'error') {
-      throw new Error(`the agent failed: ${last.errorMessage ?? 'no reason given'}`);
-    }
-    return session.getLastAssistantText() ?? '';
-  } finally {
-    unsubscribe();
-    task.signal.removeEventListener('abort', abort);
-    session.dispose();
-  }
-}
-
-export function work(task: AgentTask): Promise<string> {
-  return runSession(task, []);
-}
-
-export async function review(task: AgentTask): Promise<Verdict | undefined> {
-  let verdict: Verdict | undefined;
-  const submit = defineTool({
-    name: 'submit_verdict',
-    label: 'Submit verdict',
-    description: 'Give the result of the review. Call it once, as your last action.',
-    parameters: Type.Object({
-      summary: Type.String({ description: 'Short summary of the review' }),
-      findings: Type.Array(
-        Type.Object({
-          severity: Type.Union([Type.Literal('blocking'), Type.Literal('minor')], {
-            description:
-              'blocking for a wrong result, a missing part of the issue, a regression or a broken convention; minor for taste and style',
-          }),
-          detail: Type.String({ description: 'What is wrong and where' }),
-        }),
-        { description: 'One entry per problem. Empty when nothing is wrong.' },
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      verdict = { summary: params.summary, findings: params.findings };
-      return {
-        content: [{ type: 'text', text: 'Verdict saved.' }],
-        details: verdict,
-        terminate: true,
-      };
-    },
-  });
-  await runSession(task, [submit as unknown as ToolDefinition]);
-  return verdict;
-}

package/src/config.ts

@@ -1,69 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-
-export type Config = {
-  remote: string;
-  maxCiFixes: number;
-  maxReviewRounds: number;
-  checkTimeoutMinutes: number;
-  diffMaxChars: number;
-  logMaxChars: number;
-};
-
-export const CONFIG_FILE = join('.pi', 'next-issue.json');
-
-const DEFAULTS: Config = {
-  remote: 'origin',
-  maxCiFixes: 3,
-  maxReviewRounds: 3,
-  checkTimeoutMinutes: 30,
-  diffMaxChars: 60000,
-  logMaxChars: 20000,
-};
-
-const LEAST: Record<Exclude<keyof Config, 'remote'>, number> = {
-  maxCiFixes: 0,
-  maxReviewRounds: 1,
-  checkTimeoutMinutes: 1,
-  diffMaxChars: 1,
-  logMaxChars: 1,
-};
-
-export async function loadConfig(root: string): Promise<Config> {
-  let raw: string;
-  try {
-    raw = await readFile(join(root, CONFIG_FILE), 'utf8');
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      return { ...DEFAULTS };
-    }
-    throw error;
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`${CONFIG_FILE} is not valid JSON`);
-  }
-  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-    throw new Error(`${CONFIG_FILE} must hold an object`);
-  }
-  const config: Config = { ...DEFAULTS };
-  for (const [key, value] of Object.entries(parsed)) {
-    if (key === 'remote') {
-      if (typeof value !== 'string' || value.length === 0) {
-        throw new Error(`${CONFIG_FILE}: remote must be text that is not empty`);
-      }
-      config.remote = value;
-    } else if (key in LEAST) {
-      const least = LEAST[key as keyof typeof LEAST];
-      if (typeof value !== 'number' || !Number.isInteger(value) || value < least) {
-        throw new Error(`${CONFIG_FILE}: ${key} must be a whole number of ${least} or more`);
-      }
-      config[key as keyof typeof LEAST] = value;
-    } else {
-      throw new Error(`${CONFIG_FILE} holds an unknown field: ${key}`);
-    }
-  }
-  return config;
-}

package/src/github.ts

@@ -1,294 +0,0 @@
-import { setTimeout as sleep } from 'node:timers/promises';
-import { must, run } from './exec.ts';
-import { LABELS, STOP_LABELS, type ChecksResult, type Issue, type MergeResult } from './runner.ts';
-
-export type Repo = { root: string; slug: string };
-
-type Check = { name: string; bucket: string; link: string };
-
-const POLL_MS = 15_000;
-const GRACE_MS = 60_000;
-const READ_TRIES = 3;
-const TRUSTED = ['OWNER', 'MEMBER', 'COLLABORATOR'];
-
-function gh(repo: Repo, args: string[], input?: string): Promise<string> {
-  return must('gh', [...args, '--repo', repo.slug], {
-    cwd: repo.root,
-    ...(input === undefined ? {} : { input }),
-  });
-}
-
-export async function defaultBranch(repo: Repo): Promise<string> {
-  return must(
-    'gh',
-    ['repo', 'view', repo.slug, '--json', 'defaultBranchRef', '--jq', '.defaultBranchRef.name'],
-    {
-      cwd: repo.root,
-    },
-  );
-}
-
-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<{ open: Issue[]; closed: number[] }> {
-  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',
-    ISSUE_FIELDS,
-  ]);
-  const listed = JSON.parse(raw) as RawIssue[];
-  const known = new Set(listed.map((item) => item.number));
-  const closed: 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);
-    } else {
-      closed.push(number);
-    }
-  }
-  const open = listed
-    .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
-    .map((item) => ({
-      number: item.number,
-      title: item.title,
-      body: item.body ?? '',
-      labels: item.labels.map((label) => label.name),
-    }));
-  return { open, closed };
-}
-
-export async function comments(repo: Repo, issue: number): Promise<string[]> {
-  const raw = await gh(repo, ['issue', 'view', String(issue), '--json', 'comments']);
-  const parsed = JSON.parse(raw) as {
-    comments: Array<{ author: { login: string }; authorAssociation: string; body: string }>;
-  };
-  return parsed.comments
-    .filter((comment) => TRUSTED.includes(comment.authorAssociation))
-    .map((comment) => `@${comment.author.login}: ${comment.body}`);
-}
-
-export async function setLabel(
-  repo: Repo,
-  issue: number,
-  add: string,
-  remove: string[],
-): Promise<void> {
-  await run('gh', ['label', 'create', add, '--repo', repo.slug], { cwd: repo.root });
-  const raw = await gh(repo, [
-    'issue',
-    'view',
-    String(issue),
-    '--json',
-    'labels',
-    '--jq',
-    '.labels[].name',
-  ]);
-  const current = raw.split('\n');
-  const args = ['issue', 'edit', String(issue), '--add-label', add];
-  for (const name of remove.filter((item) => current.includes(item))) {
-    args.push('--remove-label', name);
-  }
-  await gh(repo, args);
-}
-
-export async function commentOnIssue(repo: Repo, issue: number, body: string): Promise<void> {
-  await gh(repo, ['issue', 'comment', String(issue), '--body-file', '-'], body);
-}
-
-export async function commentOnPr(repo: Repo, pr: number, body: string): Promise<void> {
-  await gh(repo, ['pr', 'comment', String(pr), '--body-file', '-'], body);
-}
-
-export async function openPr(
-  repo: Repo,
-  branch: string,
-  base: string,
-  title: string,
-  body: string,
-): Promise<number> {
-  const found = await gh(repo, [
-    'pr',
-    'list',
-    '--head',
-    branch,
-    '--state',
-    'open',
-    '--json',
-    'number',
-    '--jq',
-    '.[0].number',
-  ]);
-  if (found.length > 0) {
-    return Number(found);
-  }
-  const created = await gh(repo, [
-    'pr',
-    'create',
-    '--head',
-    branch,
-    '--base',
-    base,
-    '--title',
-    title,
-    '--body',
-    body,
-  ]);
-  const match = /\/pull\/(\d+)/.exec(created);
-  if (match === null) {
-    throw new Error(`cannot read the pull request number from: ${created}`);
-  }
-  return Number(match[1]);
-}
-
-async function readChecks(repo: Repo, pr: number): Promise<Check[]> {
-  const result = await run(
-    'gh',
-    ['pr', 'checks', String(pr), '--json', 'name,bucket,link', '--repo', repo.slug],
-    { cwd: repo.root },
-  );
-  if (result.stdout.trim().length === 0) {
-    if (/no checks reported/i.test(result.stderr)) {
-      return [];
-    }
-    throw new Error(`gh pr checks ${pr} failed with code ${result.code}: ${result.stderr.trim()}`);
-  }
-  return JSON.parse(result.stdout) as Check[];
-}
-
-export async function checks(
-  repo: Repo,
-  pr: number,
-  headSha: string,
-  timeoutMs: number,
-  signal: AbortSignal,
-): Promise<ChecksResult> {
-  const deadline = Date.now() + timeoutMs;
-  let shownAt: number | undefined;
-  let failures = 0;
-  while (Date.now() < deadline) {
-    try {
-      const prHead = await gh(repo, [
-        'pr',
-        'view',
-        String(pr),
-        '--json',
-        'headRefOid',
-        '--jq',
-        '.headRefOid',
-      ]);
-      if (prHead === headSha) {
-        shownAt ??= Date.now();
-        const list = await readChecks(repo, pr);
-        if (list.some((check) => check.bucket === 'fail' || check.bucket === 'cancel')) {
-          return 'fail';
-        }
-        if (list.length > 0 && list.every((check) => check.bucket !== 'pending')) {
-          return 'pass';
-        }
-        if (list.length === 0 && Date.now() - shownAt >= GRACE_MS) {
-          return 'pass';
-        }
-      }
-      failures = 0;
-    } catch (error) {
-      failures += 1;
-      if (failures >= READ_TRIES) {
-        throw error;
-      }
-    }
-    await sleep(Math.max(0, Math.min(POLL_MS, deadline - Date.now())), undefined, { signal });
-  }
-  return 'timeout';
-}
-
-export async function failedLogs(repo: Repo, pr: number, maxChars: number): Promise<string> {
-  const failed = (await readChecks(repo, pr)).filter(
-    (check) => check.bucket === 'fail' || check.bucket === 'cancel',
-  );
-  const groups = new Map<string, { names: string[]; runId: string | undefined }>();
-  for (const check of failed) {
-    const runId = /\/actions\/runs\/(\d+)/.exec(check.link)?.[1];
-    const key = runId ?? `check:${check.name}`;
-    const group = groups.get(key) ?? { names: [], runId };
-    group.names.push(check.name);
-    groups.set(key, group);
-  }
-  const share = Math.max(1, Math.floor(maxChars / Math.max(1, groups.size)));
-  const parts: string[] = [];
-  for (const group of groups.values()) {
-    parts.push(`## ${group.names.join(', ')}`);
-    if (group.runId !== undefined) {
-      const logs = await run(
-        'gh',
-        ['run', 'view', group.runId, '--log-failed', '--repo', repo.slug],
-        { cwd: repo.root },
-      );
-      parts.push((logs.stdout || logs.stderr).slice(-share));
-    }
-  }
-  return parts.length > 0 ? parts.join('\n\n') : 'The checks failed, but gh lists no failed check.';
-}
-
-export async function merge(
-  repo: Repo,
-  pr: number,
-  timeoutMs: number,
-  signal: AbortSignal,
-): Promise<MergeResult> {
-  const before = await gh(repo, ['pr', 'view', String(pr), '--json', 'state', '--jq', '.state']);
-  if (before === 'MERGED') {
-    return { merged: true };
-  }
-  const result = await run('gh', ['pr', 'merge', String(pr), '--squash', '--repo', repo.slug], {
-    cwd: repo.root,
-  });
-  if (result.code !== 0) {
-    return {
-      merged: false,
-      reason: result.stderr.trim().slice(-2000) || `gh pr merge failed with code ${result.code}`,
-    };
-  }
-  const deadline = Date.now() + timeoutMs;
-  for (;;) {
-    const state = await gh(repo, ['pr', 'view', String(pr), '--json', 'state', '--jq', '.state']);
-    if (state === 'MERGED') {
-      return { merged: true };
-    }
-    if (state === 'CLOSED') {
-      return { merged: false, reason: 'the pull request was closed' };
-    }
-    if (Date.now() >= deadline) {
-      return { merged: false, reason: 'the merge did not finish in time' };
-    }
-    await sleep(Math.max(0, Math.min(POLL_MS, deadline - Date.now())), undefined, { signal });
-  }
-}