@ravshansbox/pi-next-issue 0.0.0-stage → 1.0.2

package/src/github.ts

@@ -0,0 +1,245 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import { must, run } from './exec.ts';
+import type { ChecksResult, Issue } 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,
+    },
+  );
+}
+
+export async function openIssues(repo: Repo): Promise<Issue[]> {
+  const raw = await gh(repo, [
+    'issue',
+    'list',
+    '--state',
+    'open',
+    '--limit',
+    '200',
+    '--json',
+    'number,title,body,labels,createdAt',
+  ]);
+  const parsed = JSON.parse(raw) as Array<{
+    number: number;
+    title: string;
+    body: string | null;
+    createdAt: string;
+    labels: Array<{ name: string }>;
+  }>;
+  return parsed
+    .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),
+    }));
+}
+
+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 share = Math.max(1, Math.floor(maxChars / Math.max(1, failed.length)));
+  const parts: string[] = [];
+  for (const check of failed) {
+    parts.push(`## ${check.name}`);
+    const runId = /\/actions\/runs\/(\d+)/.exec(check.link)?.[1];
+    if (runId !== undefined) {
+      const logs = await run('gh', ['run', 'view', 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<boolean> {
+  const result = await run('gh', ['pr', 'merge', String(pr), '--squash', '--repo', repo.slug], {
+    cwd: repo.root,
+  });
+  if (result.code !== 0) {
+    return false;
+  }
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const state = await gh(repo, ['pr', 'view', String(pr), '--json', 'state', '--jq', '.state']);
+    if (state === 'MERGED') {
+      return true;
+    }
+    if (state === 'CLOSED' || Date.now() >= deadline) {
+      return false;
+    }
+    await sleep(Math.min(POLL_MS, deadline - Date.now()), undefined, { signal });
+  }
+}

package/src/ports.ts

@@ -0,0 +1,36 @@
+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: () => github.openIssues(repo),
+    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),
+    push: (cwd, branch) => git.push(cwd, config.remote, branch),
+    discard: (cwd) => git.discard(cwd),
+    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),
+  };
+}

package/src/prompts.ts

@@ -0,0 +1,109 @@
+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');
+}