@ravshansbox/pi-github 1.2.0 → 1.4.0

package/README.md

@@ -7,10 +7,12 @@ Watches open issues in a GitHub repo and answers new issues and comments with [p
 - Polls the repo of the current directory for new issues and comments every 30 seconds. Pull requests are ignored.
 - Only handles issues and comments created after the first start. After a restart it picks up where it stopped, including runs a crash cut off. A crash right after posting a reply can lead to that reply being posted twice.
 - Each issue gets its own git worktree in `.worktrees/issue-<number>` on branch `issue-<number>`, and its own pi session that continues across comments.
+- The terminal shows each issue's progress: every tool call the agent makes, failed tool calls, and when a branch is pushed or a pull request opened.
 - New issues and comments get an 👀 reaction as soon as they are picked up, then 🚀 once answered or 😕 if the run failed.
 - Issues are handled in parallel, up to 3 at once. Comments on the same issue are handled one after another.
 - The agent's final message is posted as a comment that starts with `agent:`. Comments that start with `agent:` are ignored, so it does not answer itself.
 - If the agent made commits, the branch is pushed and a pull request is opened once. Later commits update the same pull request.
+- When someone with write access confirms the implementation is good, the agent asks for a merge: the pull request is merged with the method the repo allows (squash, then rebase, then merge commit) and the issue is closed. Anyone without write access is refused.
 - State and sessions are kept in `.git/pi-github`.
 
 ## Requirements

package/dist/github.js

@@ -17,6 +17,9 @@ export function createGitHub({ baseUrl, token, repo }) {
         }
         return response;
     }
+    async function getRepository() {
+        return (await (await request("GET", `/repos/${repo}`)).json());
+    }
     async function list(path) {
         const items = [];
         let url = path;
@@ -48,15 +51,31 @@ export function createGitHub({ baseUrl, token, repo }) {
             const path = target.kind === "issue" ? `issues/${target.id}` : `issues/comments/${target.id}`;
             await request("POST", `/repos/${repo}/${path}/reactions`, { content });
         },
-        getDefaultBranch: async () => {
-            const data = (await (await request("GET", `/repos/${repo}`)).json());
-            return data.default_branch;
+        getDefaultBranch: async () => (await getRepository()).default_branch,
+        getMergeMethod: async () => {
+            const settings = await getRepository();
+            if (settings.allow_squash_merge)
+                return "squash";
+            if (settings.allow_rebase_merge)
+                return "rebase";
+            return "merge";
+        },
+        hasWriteAccess: async (user) => {
+            const response = await request("GET", `/repos/${repo}/collaborators/${encodeURIComponent(user)}/permission`);
+            const { permission } = (await response.json());
+            return ["admin", "maintain", "write"].includes(permission);
         },
         getIssue: async (issueNumber) => (await (await request("GET", `/repos/${repo}/issues/${issueNumber}`)).json()),
-        hasOpenPullRequest: async (branch) => {
+        findOpenPullRequest: async (branch) => {
             const owner = repo.split("/")[0];
             const response = await request("GET", `/repos/${repo}/pulls?state=open&head=${encodeURIComponent(`${owner}:${branch}`)}`);
-            return (await response.json()).length > 0;
+            return (await response.json())[0]?.number;
+        },
+        mergePullRequest: async (pullNumber, mergeMethod) => {
+            await request("PUT", `/repos/${repo}/pulls/${pullNumber}/merge`, { merge_method: mergeMethod });
+        },
+        closeIssue: async (issueNumber) => {
+            await request("PATCH", `/repos/${repo}/issues/${issueNumber}`, { state: "closed", state_reason: "completed" });
         },
         createPullRequest: async (pull) => {
             await request("POST", `/repos/${repo}/pulls`, pull);

package/dist/handler.js

@@ -1,13 +1,22 @@
 import { branchFor, ensureWorktree, hasUnpushedCommits, pushBranch } from "./git.js";
 import { agentPrefix } from "./poller.js";
-export async function handleTrigger(trigger, { github, agent, repoRoot }) {
+export async function handleTrigger(trigger, { github, agent, repoRoot, log = () => { }, }) {
     const base = await github.getDefaultBranch();
+    const branch = branchFor(trigger.issueNumber);
     const worktree = await ensureWorktree(repoRoot, trigger.issueNumber, base);
-    const answer = await agent.run(trigger, { cwd: worktree });
+    let mergeRequested = false;
+    const requestMerge = async () => {
+        if (!(await github.hasWriteAccess(trigger.author))) {
+            return `@${trigger.author} does not have write access, so the pull request will not be merged.`;
+        }
+        mergeRequested = true;
+        return "The pull request will be merged and the issue closed after you finish.";
+    };
+    const answer = await agent.run(trigger, { cwd: worktree, progress: log, requestMerge });
     if (await hasUnpushedCommits(worktree, base)) {
         await pushBranch(worktree);
-        const branch = branchFor(trigger.issueNumber);
-        if (!(await github.hasOpenPullRequest(branch))) {
+        log(`pushed ${branch}`);
+        if ((await github.findOpenPullRequest(branch)) === undefined) {
             const issue = await github.getIssue(trigger.issueNumber);
             await github.createPullRequest({
                 head: branch,
@@ -15,7 +24,26 @@ export async function handleTrigger(trigger, { github, agent, repoRoot }) {
                 title: issue.title,
                 body: `${agentPrefix} Closes #${trigger.issueNumber}`,
             });
+            log("opened a pull request");
+        }
+    }
+    let note = "";
+    if (mergeRequested) {
+        const pullNumber = await github.findOpenPullRequest(branch);
+        if (pullNumber === undefined) {
+            note = "\n\nThere is no open pull request for this issue, so nothing was merged.";
+        }
+        else {
+            try {
+                await github.mergePullRequest(pullNumber, await github.getMergeMethod());
+                log(`merged pull request #${pullNumber}`);
+                await github.closeIssue(trigger.issueNumber);
+                log("closed the issue");
+            }
+            catch (error) {
+                note = `\n\nMerging failed: ${error instanceof Error ? error.message : error}`;
+            }
         }
     }
-    await github.postComment(trigger.issueNumber, `${agentPrefix} ${answer}`);
+    await github.postComment(trigger.issueNumber, `${agentPrefix} ${answer}${note}`);
 }

package/dist/pi-agent.js

@@ -1,11 +1,26 @@
 import { join } from "node:path";
-import { createAgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, defineTool, SessionManager } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { describeToolCall } from "./progress.js";
 import { buildPrompt } from "./prompt.js";
 export function createPiAgent({ github, repo, sessionsDir }) {
     return {
-        async run(trigger, { cwd }) {
+        async run(trigger, { cwd, progress, requestMerge }) {
             const sessionManager = SessionManager.continueRecent(cwd, join(sessionsDir, `issue-${trigger.issueNumber}`));
-            const { session } = await createAgentSession({ cwd, sessionManager });
+            const mergeTool = defineTool({
+                name: "merge_pull_request",
+                label: "Merge pull request",
+                description: "Merge this issue's pull request into the default branch and close the issue, once you have finished. Call it only when the latest comment confirms the implementation is good.",
+                parameters: Type.Object({}),
+                execute: async () => ({ content: [{ type: "text", text: await requestMerge() }], details: {} }),
+            });
+            const { session } = await createAgentSession({ cwd, sessionManager, customTools: [mergeTool] });
+            const unsubscribe = session.subscribe((event) => {
+                if (event.type === "tool_execution_start" && !event.parentToolCallId)
+                    progress(describeToolCall(event.toolName, event.args));
+                if (event.type === "tool_execution_end" && event.isError && !event.parentToolCallId)
+                    progress(`${event.toolName} failed`);
+            });
             try {
                 const issue = await github.getIssue(trigger.issueNumber);
                 const firstInSession = session.messages.length === 0;
@@ -13,6 +28,7 @@ export function createPiAgent({ github, repo, sessionsDir }) {
                 return session.getLastAssistantText() ?? "";
             }
             finally {
+                unsubscribe();
                 session.dispose();
             }
         },

package/dist/progress.js

@@ -0,0 +1,8 @@
+const maximumLength = 100;
+export function describeToolCall(toolName, args) {
+    const values = args !== null && typeof args === "object" ? args : {};
+    const detail = ["command", "path", "pattern", "query"].map((key) => values[key]).find((value) => typeof value === "string") ??
+        JSON.stringify(args ?? {});
+    const line = detail.split("\n")[0] ?? "";
+    return `${toolName}: ${line.length > maximumLength ? `${line.slice(0, maximumLength - 1)}…` : line}`;
+}

package/dist/prompt.js

@@ -8,6 +8,7 @@ export function buildPrompt({ repo, issue, trigger, firstInSession, }) {
         `Your working directory is a git worktree on branch ${branchFor(issue.number)}.`,
         "If the request needs code changes, make them and commit them. Do not push and do not open pull requests; that happens automatically after you finish.",
         "Your final message is posted as a comment on the issue, so write it for the person who asked.",
+        "When a comment confirms the implementation is good, call merge_pull_request.",
         ...(trigger.kind === "comment" ? [`Issue description:\n\n${issue.body ?? ""}`] : []),
         message,
     ].join("\n\n");

package/dist/watch.js

@@ -37,7 +37,7 @@ export async function watch({ github, agent, repoRoot, stateFile, intervalMs, co
         concurrency,
         handle: async (trigger) => {
             try {
-                await handleTrigger(trigger, { github, agent, repoRoot });
+                await handleTrigger(trigger, { github, agent, repoRoot, log: (message) => log(`#${trigger.issueNumber}: ${message}`) });
                 log(`#${trigger.issueNumber}: answered @${trigger.author}`);
                 await react(trigger, "rocket");
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ravshansbox/pi-github",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Watch GitHub issues and answer them with pi agents",
   "type": "module",
   "license": "MIT",
@@ -20,7 +20,8 @@
     "prepare": "tsc"
   },
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "^1.4.0"
+    "@earendil-works/pi-coding-agent": "^1.4.0",
+    "typebox": "^1.3.27"
   },
   "devDependencies": {
     "@types/node": "^26.6.6",