@ravshansbox/pi-next-issue 1.2.0 → 2.3.0

package/src/ports.ts

@@ -1,43 +0,0 @@
-import * as agent from './agent.ts';
-import type { Config } from './config.ts';
-import * as git from './git.ts';
-import * as github from './github.ts';
-import type { Ports } from './runner.ts';
-import * as state from './state.ts';
-
-export async function createPorts(root: string, config: Config): Promise<Ports> {
-  const repo: github.Repo = { root, slug: await git.remoteSlug(root, config.remote) };
-  const base = await github.defaultBranch(repo);
-  const timeoutMs = config.checkTimeoutMinutes * 60_000;
-  return {
-    openIssues: async () => {
-      const { open, closed } = await github.openIssues(repo, await state.savedIssues(root));
-      await Promise.all(closed.map((issue) => state.dropState(root, issue)));
-      return open;
-    },
-    comments: (issue) => github.comments(repo, issue),
-    setLabel: (issue, add, remove) => github.setLabel(repo, issue, add, remove),
-    commentOnIssue: (issue, body) => github.commentOnIssue(repo, issue, body),
-    worktree: (issue, branch) => git.worktree(root, config.remote, base, issue, branch),
-    commit: (cwd, message) => git.commit(cwd, message),
-    ahead: (cwd) => git.ahead(cwd, config.remote, base),
-    push: (cwd, branch) => git.push(cwd, config.remote, branch),
-    discard: (cwd, branch) => git.discard(cwd, config.remote, branch),
-    diff: (cwd) => git.diff(cwd, config.remote, base),
-    openPr: (branch, title, body) => github.openPr(repo, branch, base, title, body),
-    checks: async (pr, cwd, signal) =>
-      github.checks(repo, pr, await git.head(cwd), timeoutMs, signal),
-    failedLogs: (pr) => github.failedLogs(repo, pr, config.logMaxChars),
-    commentOnPr: (pr, body) => github.commentOnPr(repo, pr, body),
-    merge: (pr, signal) => github.merge(repo, pr, timeoutMs, signal),
-    cleanup: (_issue, branch, cwd) => git.cleanup(root, config.remote, branch, cwd),
-    work: agent.work,
-    review: agent.review,
-    readState: (issue) => state.readState(root, issue),
-    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/prompts.ts

@@ -1,109 +0,0 @@
-import type { Finding, Issue, Verdict } from './runner.ts';
-
-const COMMIT_RULES = [
-  'Do not run git, gh or any push command. The harness commits for you.',
-  'End your final message with one line in the form `commit: <conventional commit subject>`.',
-].join('\n');
-
-function issueBlock(issue: Issue, comments: string[]): string {
-  return [
-    `# Issue #${issue.number}: ${issue.title}`,
-    issue.body.length > 0 ? issue.body : '(no description)',
-    comments.length > 0 ? `## Comments\n${comments.join('\n\n')}` : '',
-  ]
-    .filter((part) => part.length > 0)
-    .join('\n\n');
-}
-
-export function implementPrompt(issue: Issue, comments: string[]): string {
-  return [
-    'You are the implementer. Solve the issue below in this worktree.',
-    issueBlock(issue, comments),
-    '## Rules',
-    'Read the repository conventions first. Keep the change minimal and focused on the issue.',
-    'Add or update tests when the repository has a test suite.',
-    COMMIT_RULES,
-  ].join('\n\n');
-}
-
-export function reviewPrompt(
-  issue: Issue,
-  comments: string[],
-  diff: string,
-  earlier: string[],
-): string {
-  const scope =
-    earlier.length === 0
-      ? 'Check correctness, scope, repository conventions and test cover.'
-      : [
-          'This is a later round. Judge only whether the earlier findings below are fixed and whether the new commits broke something.',
-          'Do not raise a new point of taste. Withdraw a finding when the fixer disputed it correctly.',
-          `## Earlier rounds\n${earlier.join('\n\n')}`,
-        ].join('\n');
-  return [
-    'You are the reviewer. Judge whether the diff solves the issue correctly.',
-    issueBlock(issue, comments),
-    '## Diff',
-    '```diff',
-    diff,
-    '```',
-    '## Rules',
-    'Read files and run commands to prove what you say: the tests, the type check or the linter.',
-    'Do not change a file. Do not write with git or gh. The harness discards each change that you make.',
-    scope,
-    'Mark a finding blocking only for a wrong result, a missing part of the issue, a regression or a broken convention.',
-    'Finish by calling the submit_verdict tool once with a short summary and one entry per finding.',
-  ].join('\n\n');
-}
-
-export function fixPrompt(issue: Issue, reason: string, detail: string, earlier: string[]): string {
-  return [
-    `You are the fixer. Correct the work for issue #${issue.number}: ${issue.title}.`,
-    `## Reason\n${reason}`,
-    `## Detail\n${detail}`,
-    earlier.length > 0
-      ? `## Earlier rounds\n${earlier.join('\n\n')}\n\nKeep those earlier fixes.`
-      : '',
-    '## Rules',
-    'Fix the cause, not the symptom. Keep the change minimal. Do not weaken, skip or delete a test to make it pass.',
-    'If the problem is not caused by this change, or every finding is wrong, change nothing and end your final message with one line in the form `unrelated: <one sentence on why>`.',
-    COMMIT_RULES,
-  ]
-    .filter((part) => part.length > 0)
-    .join('\n\n');
-}
-
-function lastLine(text: string, key: string): string | undefined {
-  const match = [...text.matchAll(new RegExp(`^${key}:\\s*(.+)$`, 'gim'))].at(-1);
-  const value = match?.[1]
-    ?.trim()
-    .replace(/^`+|`+$/g, '')
-    .trim();
-  return value !== undefined && value.length > 0 ? value : undefined;
-}
-
-export function parseCommitSubject(text: string, fallback: string): string {
-  return lastLine(text, 'commit') ?? fallback;
-}
-
-export function parseUnrelated(text: string): string | undefined {
-  return lastLine(text, 'unrelated');
-}
-
-export function cap(text: string, maxChars: number): string {
-  return text.length <= maxChars
-    ? text
-    : `${text.slice(0, maxChars)}\n... cut after ${maxChars} characters.`;
-}
-
-export function formatVerdict(verdict: Verdict, open: Finding[]): string {
-  const head = open.length === 0 ? 'Review: approved' : 'Review: changes requested';
-  const lines = verdict.findings.map((finding) => `- **${finding.severity}** ${finding.detail}`);
-  return [`### ${head}`, verdict.summary, lines.join('\n')]
-    .filter((part) => part.length > 0)
-    .join('\n\n');
-}
-
-export function formatFindings(findings: Finding[]): string {
-  return findings.map((finding) => `- ${finding.detail}`).join('\n');
-}

package/src/runner.ts

@@ -1,358 +0,0 @@
-import type { Config } from './config.ts';
-import {
-  cap,
-  fixPrompt,
-  formatFindings,
-  formatVerdict,
-  implementPrompt,
-  parseCommitSubject,
-  parseUnrelated,
-  reviewPrompt,
-} from './prompts.ts';
-
-export type Issue = { number: number; title: string; body: string; labels: string[] };
-
-export type Finding = { severity: 'blocking' | 'minor'; detail: string };
-
-export type Verdict = { summary: string; findings: Finding[] };
-
-export type ChecksResult = 'pass' | 'fail' | 'timeout';
-
-export type Phase = 'implement' | 'publish' | 'checks' | 'review' | 'merge';
-
-export type IssueState = {
-  issue: number;
-  branch: string;
-  phase: Phase;
-  pr?: number;
-  title?: string | undefined;
-  ciFixes: number;
-  round: number;
-  earlier: string[];
-};
-
-export type AgentTask = {
-  cwd: string;
-  prompt: string;
-  signal: AbortSignal;
-  onTool: (label: string) => void;
-};
-
-export type Ports = {
-  openIssues(): Promise<Issue[]>;
-  comments(issue: number): Promise<string[]>;
-  setLabel(issue: number, add: string, remove: string[]): Promise<void>;
-  commentOnIssue(issue: number, body: string): Promise<void>;
-  worktree(issue: number, branch: string): Promise<string>;
-  commit(cwd: string, message: string): Promise<boolean>;
-  ahead(cwd: string): Promise<string | undefined>;
-  push(cwd: string, branch: string): Promise<void>;
-  discard(cwd: string, branch: string): Promise<void>;
-  diff(cwd: string): Promise<string>;
-  openPr(branch: string, title: string, body: string): Promise<number>;
-  checks(pr: number, cwd: string, signal: AbortSignal): Promise<ChecksResult>;
-  failedLogs(pr: number): Promise<string>;
-  commentOnPr(pr: number, body: string): Promise<void>;
-  merge(pr: number, signal: AbortSignal): Promise<MergeResult>;
-  cleanup(issue: number, branch: string, cwd: string): Promise<void>;
-  work(task: AgentTask): Promise<string>;
-  review(task: AgentTask): Promise<Verdict | undefined>;
-  readState(issue: number): Promise<IssueState | undefined>;
-  writeState(state: IssueState): Promise<void>;
-  dropState(issue: number): Promise<void>;
-  savedIssues(): Promise<number[]>;
-  lock(): Promise<void>;
-  unlock(): Promise<void>;
-};
-
-export type MergeResult = { merged: true } | { merged: false; reason: string };
-
-export type Outcome = 'merged' | 'needs-human';
-
-export type Status = 'idle' | 'running' | 'stopping' | 'finished' | 'stopped' | 'failed';
-
-export type Progress = {
-  status: Status;
-  issue?: number | undefined;
-  title?: string | undefined;
-  stage?: string | undefined;
-  tools: number;
-  lastTool?: string | undefined;
-  issueStartedAt?: number;
-  handled: Array<{ issue: number; outcome: Outcome }>;
-  error?: string;
-};
-
-export const LABELS = {
-  ready: 'status:todo',
-  inProgress: 'status:in-progress',
-  done: 'status:done',
-  needsHuman: 'status:needs-human',
-  blocked: 'status:blocked',
-};
-
-export const STOP_LABELS = [LABELS.inProgress, LABELS.done, LABELS.needsHuman, LABELS.blocked];
-
-function ready(issue: Issue): boolean {
-  return (
-    issue.labels.includes(LABELS.ready) &&
-    !issue.labels.some((label) => STOP_LABELS.includes(label))
-  );
-}
-
-function resumable(issue: Issue): boolean {
-  return !issue.labels.some((label) => label !== LABELS.inProgress && STOP_LABELS.includes(label));
-}
-
-export class Runner {
-  progress: Progress = { status: 'idle', tools: 0, handled: [] };
-  private readonly controller = new AbortController();
-  private readonly listeners = new Set<(progress: Progress) => void>();
-
-  private readonly ports: Ports;
-  private readonly config: Config;
-
-  constructor(ports: Ports, config: Config) {
-    this.ports = ports;
-    this.config = config;
-  }
-
-  subscribe(listener: (progress: Progress) => void): () => void {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-
-  stop(): void {
-    if (this.progress.status === 'running') {
-      this.update({ status: 'stopping' });
-    }
-    this.controller.abort();
-  }
-
-  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();
-        const saved = new Set(await this.ports.savedIssues());
-        const fresh = issues.filter((item) => !seen.has(item.number));
-        const next =
-          fresh.find((item) => saved.has(item.number) && resumable(item)) ??
-          fresh.find((item) => ready(item));
-        if (next === undefined) {
-          this.update({ status: 'finished', stage: undefined, issue: undefined, title: undefined });
-          return;
-        }
-        seen.add(next.number);
-        const outcome = await this.handle(next, await this.ports.readState(next.number));
-        this.update({ handled: [...this.progress.handled, { issue: next.number, outcome }] });
-      }
-    } catch (error) {
-      if (this.controller.signal.aborted) {
-        this.update({ status: 'stopped' });
-      } else {
-        this.update({
-          status: 'failed',
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    } finally {
-      if (locked) {
-        await this.ports.unlock().catch(() => {});
-      }
-    }
-  }
-
-  private update(change: Partial<Progress>): void {
-    this.progress = { ...this.progress, ...change };
-    for (const listener of this.listeners) {
-      listener(this.progress);
-    }
-  }
-
-  private stage(stage: string): void {
-    this.controller.signal.throwIfAborted();
-    this.update({ stage });
-  }
-
-  private async agent(kind: 'work', cwd: string, prompt: string): Promise<string>;
-  private async agent(kind: 'review', cwd: string, prompt: string): Promise<Verdict | undefined>;
-  private async agent(
-    kind: 'work' | 'review',
-    cwd: string,
-    prompt: string,
-  ): Promise<string | Verdict | undefined> {
-    const task: AgentTask = {
-      cwd,
-      prompt,
-      signal: this.controller.signal,
-      onTool: (label) => this.update({ tools: this.progress.tools + 1, lastTool: label }),
-    };
-    const result = kind === 'work' ? await this.ports.work(task) : await this.ports.review(task);
-    this.controller.signal.throwIfAborted();
-    return result;
-  }
-
-  private async handle(issue: Issue, saved: IssueState | undefined): Promise<Outcome> {
-    const { ports, config } = this;
-    const number = issue.number;
-    this.update({
-      issue: number,
-      title: issue.title,
-      stage: 'prepare',
-      tools: 0,
-      lastTool: undefined,
-      issueStartedAt: Date.now(),
-    });
-    let state: IssueState = saved ?? {
-      issue: number,
-      branch: String(number),
-      phase: 'implement',
-      ciFixes: 0,
-      round: 0,
-      earlier: [],
-    };
-    const save = async (change: Partial<IssueState>) => {
-      state = { ...state, ...change };
-      await ports.writeState(state);
-    };
-    const needsHuman = async (reason: string): Promise<Outcome> => {
-      await ports.setLabel(number, LABELS.needsHuman, [LABELS.inProgress]);
-      await ports.commentOnIssue(number, `next-issue stopped: ${reason}`);
-      await ports.dropState(number);
-      return 'needs-human';
-    };
-    if (saved === undefined) {
-      await ports.setLabel(number, LABELS.inProgress, [LABELS.ready]);
-      await ports.writeState(state);
-    }
-    const comments = await ports.comments(number);
-    const cwd = await ports.worktree(number, state.branch);
-    const pr = () => {
-      if (state.pr === undefined) {
-        throw new Error(`the saved state of #${number} holds no pull request`);
-      }
-      return state.pr;
-    };
-    for (;;) {
-      switch (state.phase) {
-        case 'implement': {
-          this.stage('implement');
-          const kept = saved === undefined ? undefined : await ports.ahead(cwd);
-          if (kept !== undefined) {
-            await save({ phase: 'publish', title: kept });
-            break;
-          }
-          const reply = await this.agent('work', cwd, implementPrompt(issue, comments));
-          const title = parseCommitSubject(reply, `feat: ${issue.title}`);
-          if (!(await ports.commit(cwd, title))) {
-            return needsHuman('the implementer made no change');
-          }
-          await save({ phase: 'publish', title });
-          break;
-        }
-        case 'publish': {
-          this.stage('pull request');
-          await ports.push(cwd, state.branch);
-          const title = state.title ?? `feat: ${issue.title}`;
-          await save({
-            phase: 'checks',
-            pr: await ports.openPr(state.branch, title, `Closes #${number}`),
-          });
-          break;
-        }
-        case 'checks': {
-          this.stage('checks');
-          const result = await ports.checks(pr(), cwd, this.controller.signal);
-          if (result === 'pass') {
-            await save({ phase: 'review' });
-            break;
-          }
-          if (result === 'timeout') {
-            return needsHuman('the checks did not finish in time');
-          }
-          if (state.ciFixes >= config.maxCiFixes) {
-            return needsHuman(`the checks still fail after ${config.maxCiFixes} fixes`);
-          }
-          this.stage(`fix checks ${state.ciFixes + 1}/${config.maxCiFixes}`);
-          const logs = cap(await ports.failedLogs(pr()), config.logMaxChars);
-          const reply = await this.agent(
-            'work',
-            cwd,
-            fixPrompt(issue, 'The checks failed.', logs, []),
-          );
-          if (!(await ports.commit(cwd, parseCommitSubject(reply, 'fix: make the checks pass')))) {
-            return needsHuman(
-              `the fixer made no change: ${parseUnrelated(reply) ?? 'no reason given'}`,
-            );
-          }
-          await ports.push(cwd, state.branch);
-          await save({ ciFixes: state.ciFixes + 1 });
-          break;
-        }
-        case 'review': {
-          const round = state.round + 1;
-          const last = round >= config.maxReviewRounds;
-          this.stage(`review ${round}/${config.maxReviewRounds}`);
-          const diff = cap(await ports.diff(cwd), config.diffMaxChars);
-          const verdict = await this.agent(
-            'review',
-            cwd,
-            reviewPrompt(issue, comments, diff, state.earlier),
-          );
-          await ports.discard(cwd, state.branch);
-          if (verdict === undefined) {
-            return needsHuman('the reviewer gave no verdict');
-          }
-          const open = last
-            ? verdict.findings.filter((finding) => finding.severity === 'blocking')
-            : verdict.findings;
-          await ports.commentOnPr(pr(), formatVerdict(verdict, open));
-          if (open.length === 0) {
-            await save({ phase: 'merge', round });
-            break;
-          }
-          if (last) {
-            return needsHuman('blocking review findings are left after the last round');
-          }
-          this.stage(`fix review ${round}/${config.maxReviewRounds}`);
-          const findings = formatFindings(open);
-          const reply = await this.agent(
-            'work',
-            cwd,
-            fixPrompt(issue, 'The reviewer found problems.', findings, state.earlier),
-          );
-          const committed = await ports.commit(
-            cwd,
-            parseCommitSubject(reply, 'fix: address the review'),
-          );
-          const dispute = committed
-            ? ''
-            : `\nThe fixer disputed every finding of this round: ${parseUnrelated(reply) ?? 'no reason given'}`;
-          const earlier = [...state.earlier, `Round ${round}:\n${findings}${dispute}`];
-          if (committed) {
-            await ports.push(cwd, state.branch);
-          }
-          await save({ phase: committed ? 'checks' : 'review', round, earlier });
-          break;
-        }
-        case 'merge': {
-          this.stage('merge');
-          const result = await ports.merge(pr(), this.controller.signal);
-          if (!result.merged) {
-            return needsHuman(`pull request #${pr()} could not be merged: ${result.reason}`);
-          }
-          await ports.setLabel(number, LABELS.done, [LABELS.inProgress]);
-          await ports.cleanup(number, state.branch, cwd);
-          await ports.dropState(number);
-          return 'merged';
-        }
-      }
-    }
-  }
-}

package/src/state.ts

@@ -1,121 +0,0 @@
-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';
-
-function dir(root: string): string {
-  return join(root, WORKTREE_DIR);
-}
-
-function file(root: string, issue: number): string {
-  return join(dir(root), `${issue}.json`);
-}
-
-export async function readState(root: string, issue: number): Promise<IssueState | undefined> {
-  try {
-    return JSON.parse(await readFile(file(root, issue), 'utf8')) as IssueState;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      return undefined;
-    }
-    throw new Error(`the state of #${issue} cannot be read: ${(error as Error).message}`);
-  }
-}
-
-export async function writeState(root: string, state: IssueState): Promise<void> {
-  await mkdir(dir(root), { recursive: true });
-  await writeFile(file(root, state.issue), `${JSON.stringify(state, null, 2)}\n`);
-}
-
-export async function dropState(root: string, issue: number): Promise<void> {
-  await rm(file(root, issue), { force: true });
-}
-
-export async function savedIssues(root: string): Promise<number[]> {
-  const names = await readdir(dir(root)).catch(() => []);
-  return names.flatMap((name) => {
-    const match = /^(\d+)\.json$/.exec(name);
-    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 });
-  }
-}