Clean up fork setup

external.ts

@@ -193,7 +193,6 @@ interface FixReviewEvent extends BasePayloadEvent {
   review_id: number;
   /** "all" to fix all comments, or specific comment IDs to fix */
   comment_ids: number[] | "all";
-  branch: string;
 }
 
 interface UnknownEvent extends BasePayloadEvent {

main.ts

@@ -2,6 +2,7 @@ import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { flatMorph } from "@ark/util";
+import { Octokit } from "@octokit/rest";
 import { encode as toonEncode } from "@toon-format/toon";
 import { type } from "arktype";
 import { agents } from "./agents/index.ts";
@@ -11,18 +12,17 @@ import { agentsManifest } from "./external.ts";
 import { ensureProgressCommentUpdated, reportProgress } from "./mcp/comment.ts";
 import { createMcpConfigs } from "./mcp/config.ts";
 import { startMcpHttpServer } from "./mcp/server.ts";
-import { getModes, modes } from "./modes.ts";
+import { getModes, type Mode, modes } from "./modes.ts";
 import packageJson from "./package.json" with { type: "json" };
-import { fetchRepoSettings, fetchWorkflowRunInfo } from "./utils/api.ts";
+import { fetchRepoSettings, fetchWorkflowRunInfo, type RepoSettings } from "./utils/api.ts";
 import { log } from "./utils/cli.ts";
 import { reportErrorToComment } from "./utils/errorReport.ts";
 import {
   parseRepoContext,
-  type RepoContext,
   revokeGitHubInstallationToken,
   setupGitHubInstallationToken,
 } from "./utils/github.ts";
-import { setupGitAuth, setupGitBranch, setupGitConfig } from "./utils/setup.ts";
+import { setupGit, setupGitConfig } from "./utils/setup.ts";
 import { Timer } from "./utils/timer.ts";
 
 // runtime validation using agents (needed for ArkType)
@@ -61,19 +61,16 @@ export async function main(inputs: Inputs): Promise<MainResult> {
     payload = parsePayload(inputs);
 
     const partialCtx = await initializeContext(inputs, payload);
-    const ctx = partialCtx as MainContext;
+    const ctx = partialCtx as Context;
     timer.checkpoint("initializeContext");
 
-    setupGitAuth({
-      githubInstallationToken: ctx.githubInstallationToken,
-      repoContext: ctx.repoContext,
-    });
+    const { pushRemote } = await setupGit(ctx);
+    ctx.pushRemote = pushRemote;
+    timer.checkpoint("setupGit");
 
     await setupTempDirectory(ctx);
     timer.checkpoint("setupTempDirectory");
 
-    setupGitBranch(ctx.payload);
-
     await startMcpServer(ctx);
     mcpServerClose = ctx.mcpServerClose;
     timer.checkpoint("startMcpServer");
@@ -84,7 +81,7 @@ export async function main(inputs: Inputs): Promise<MainResult> {
       Array.isArray(ctx.payload.event.comment_ids) &&
       ctx.payload.event.comment_ids.length === 0
     ) {
-      await reportProgress({
+      await reportProgress(ctx, {
         body: `👍 **No approved comments found**\n\nTo use "Fix 👍s", add a 👍 reaction to one or more inline review comments you want fixed.`,
       });
       return { success: true };
@@ -157,36 +154,26 @@ function getAllPossibleKeyNames(): string[] {
 /**
  * Throw an error for missing API key with helpful message linking to repo settings
  */
-async function throwMissingApiKeyError({
-  agent,
-  repoContext,
-}: {
-  agent: (typeof agents)[AgentName] | null;
-  repoContext: RepoContext;
-}): Promise<never> {
+async function throwMissingApiKeyError(ctx: Context): Promise<never> {
   const apiUrl = process.env.API_URL || "https://pullfrog.com";
-  const settingsUrl = `${apiUrl}/console/${repoContext.owner}/${repoContext.name}`;
+  const settingsUrl = `${apiUrl}/console/${ctx.owner}/${ctx.name}`;
 
-  const githubRepoUrl = `https://github.com/${repoContext.owner}/${repoContext.name}`;
+  const githubRepoUrl = `https://github.com/${ctx.owner}/${ctx.name}`;
   const githubSecretsUrl = `${githubRepoUrl}/settings/secrets/actions`;
 
   // for OpenCode, use a generic message since it accepts any API key
-  const isOpenCode = agent?.name === "opencode";
+  const isOpenCode = ctx.agent?.name === "opencode";
   let secretNameList: string;
   if (isOpenCode) {
     secretNameList =
       "any API key (e.g., `OPENCODE_API_KEY`, `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, etc.)";
   } else {
-    const inputKeys = agent?.apiKeyNames || getAllPossibleKeyNames();
+    const inputKeys = ctx.agent?.apiKeyNames || getAllPossibleKeyNames();
     const secretNames = inputKeys.map((key) => `\`${key.toUpperCase()}\``);
     secretNameList = inputKeys.length === 1 ? secretNames[0] : `one of ${secretNames.join(" or ")}`;
   }
 
-  let message = `${
-    agent === null
-      ? "Pullfrog has no agent configured and no API keys are available in the environment."
-      : `Pullfrog is configured to use ${agent.displayName}, but the associated API key was not provided.`
-  }
+  const message = `Pullfrog is configured to use ${ctx.agent.displayName}, but the associated API key was not provided.
 
 To fix this, add the required secret to your GitHub repository:
 
@@ -194,28 +181,45 @@ To fix this, add the required secret to your GitHub repository:
 2. Click "New repository secret"
 3. Set the name to ${secretNameList}
 4. Set the value to your API key
-5. Click "Add secret"`;
+5. Click "Add secret"
 
-  if (agent === null) {
-    message += `\n\nAlternatively, configure Pullfrog to use an agent at ${settingsUrl}`;
-  }
+Alternatively, configure Pullfrog to use a different agent at ${settingsUrl}`;
 
   // report to comment if MCP context is available (server has started)
   await reportErrorToComment({ error: message });
   throw new Error(message);
 }
 
-interface MainContext {
+export interface Context {
+  // flattened from RepoContext
+  owner: string;
+  name: string;
+
+  // core fields
   inputs: Inputs;
-  githubInstallationToken: string;
-  repoContext: RepoContext;
+  payload: Payload;
+  repo: Awaited<ReturnType<Octokit["repos"]["get"]>>["data"];
   agentName: AgentName;
   agent: (typeof agents)[AgentName];
+  githubInstallationToken: string;
+  octokit: Octokit;
+
+  // repo settings from Pullfrog API
+  repoSettings: RepoSettings;
+
+  // modes for MCP tools
+  modes: Mode[];
+
+  // setup fields
+  pushRemote: string;
   sharedTempDir: string;
-  payload: Payload;
+
+  // mcp fields
   mcpServerUrl: string;
   mcpServerClose: () => Promise<void>;
   mcpServers: ReturnType<typeof createMcpConfigs>;
+
+  // agent fields
   cliPath: string;
   apiKey: string;
   apiKeys: Record<string, string>;
@@ -226,8 +230,14 @@ async function initializeContext(
   payload: Payload
 ): Promise<
   Omit<
-    MainContext,
-    "mcpServerUrl" | "mcpServerClose" | "mcpServers" | "cliPath" | "apiKey" | "apiKeys"
+    Context,
+    | "mcpServerUrl"
+    | "mcpServerClose"
+    | "mcpServers"
+    | "cliPath"
+    | "apiKey"
+    | "apiKeys"
+    | "pushRemote"
   >
 > {
   log.info(`🐸 Running pullfrog/action@${packageJson.version}...`);
@@ -235,39 +245,65 @@ async function initializeContext(
   setupGitConfig();
 
   const githubInstallationToken = await setupGitHubInstallationToken();
-  const repoContext = parseRepoContext();
+  const { owner, name } = parseRepoContext();
+
+  // create octokit instance
+  const octokit = new Octokit({
+    auth: githubInstallationToken,
+  });
+
+  // fetch repo data
+  const response = await octokit.repos.get({
+    owner,
+    repo: name,
+  });
+  const repo = response.data;
+
+  // fetch repo settings
+  const repoSettings = await fetchRepoSettings({
+    token: githubInstallationToken,
+    repoContext: { owner, name },
+  });
 
   // resolve agent and update payload with resolved agent name
-  const { agentName, agent } = await resolveAgent(
+  const { agentName, agent } = resolveAgent({
     inputs,
     payload,
-    githubInstallationToken,
-    repoContext
-  );
+    repoSettings,
+  });
   const resolvedPayload = { ...payload, agent: agentName };
 
+  // compute modes from defaults + payload overrides
+  const computedModes = [
+    ...getModes({ disableProgressComment: resolvedPayload.disableProgressComment }),
+    ...(resolvedPayload.modes || []),
+  ];
+
   return {
+    owner,
+    name,
     inputs,
     githubInstallationToken,
-    repoContext,
+    octokit,
+    repo,
     agentName,
     agent,
     payload: resolvedPayload,
+    repoSettings,
+    modes: computedModes,
     sharedTempDir: "",
   };
 }
 
-async function resolveAgent(
-  inputs: Inputs,
-  payload: Payload,
-  githubInstallationToken: string,
-  repoContext: RepoContext
-): Promise<{ agentName: AgentName; agent: (typeof agents)[AgentName] }> {
-  const repoSettings = await fetchRepoSettings({
-    token: githubInstallationToken,
-    repoContext,
-  });
-
+function resolveAgent({
+  inputs,
+  payload,
+  repoSettings,
+}: {
+  inputs: Inputs;
+  payload: Payload;
+  repoSettings: RepoSettings;
+}): { agentName: AgentName; agent: (typeof agents)[AgentName] } {
   const agentOverride = process.env.AGENT_OVERRIDE as AgentName | undefined;
   const configuredAgentName = agentOverride || payload.agent || repoSettings.defaultAgent || null;
 
@@ -312,10 +348,8 @@ async function resolveAgent(
   log.debug(`Available agents: ${availableAgentNames || "none"}`);
 
   if (availableAgents.length === 0) {
-    await throwMissingApiKeyError({
-      agent: null,
-      repoContext,
-    });
+    // this will be caught and reported later in validateApiKey
+    throw new Error("no agents available - missing API keys");
   }
 
   const agentName = availableAgents[0].name;
@@ -324,9 +358,7 @@ async function resolveAgent(
   return { agentName, agent };
 }
 
-async function setupTempDirectory(
-  ctx: Omit<MainContext, "payload" | "mcpServers" | "cliPath" | "apiKey">
-): Promise<void> {
+async function setupTempDirectory(ctx: Context): Promise<void> {
   ctx.sharedTempDir = await mkdtemp(join(tmpdir(), "pullfrog-"));
   process.env.PULLFROG_TEMP_DIR = ctx.sharedTempDir;
   log.info(`📂 PULLFROG_TEMP_DIR has been created at ${ctx.sharedTempDir}`);
@@ -352,7 +384,7 @@ function parsePayload(inputs: Inputs): Payload {
   }
 }
 
-async function startMcpServer(ctx: MainContext): Promise<void> {
+async function startMcpServer(ctx: Context): Promise<void> {
   // fetch the pre-created progress comment ID from the database
   // this must be set BEFORE starting the MCP server so comment.ts can read it
   const runId = process.env.GITHUB_RUN_ID;
@@ -364,26 +396,18 @@ async function startMcpServer(ctx: MainContext): Promise<void> {
     }
   }
 
-  const allModes = [
-    ...getModes({ disableProgressComment: ctx.payload.disableProgressComment }),
-    ...(ctx.payload.modes || []),
-  ];
-  const { url, close } = await startMcpHttpServer({
-    payload: ctx.payload,
-    modes: allModes,
-    agentName: ctx.agentName,
-  });
+  const { url, close } = await startMcpHttpServer(ctx);
   ctx.mcpServerUrl = url;
   ctx.mcpServerClose = close;
   log.info(`🚀 MCP server started at ${url}`);
 }
 
-function setupMcpServers(ctx: MainContext): void {
+function setupMcpServers(ctx: Context): void {
   ctx.mcpServers = createMcpConfigs(ctx.mcpServerUrl);
   log.debug(`📋 MCP Config: ${JSON.stringify(ctx.mcpServers, null, 2)}`);
 }
 
-async function installAgentCli(ctx: MainContext): Promise<void> {
+async function installAgentCli(ctx: Context): Promise<void> {
   // gemini is the only agent that needs githubInstallationToken for install
   if (ctx.agentName === "gemini") {
     ctx.cliPath = await ctx.agent.install(ctx.githubInstallationToken);
@@ -392,7 +416,7 @@ async function installAgentCli(ctx: MainContext): Promise<void> {
   }
 }
 
-async function validateApiKey(ctx: MainContext): Promise<void> {
+async function validateApiKey(ctx: Context): Promise<void> {
   // collect all matching API keys for this agent
   const apiKeys: Record<string, string> = {};
   for (const inputKey of ctx.agent.apiKeyNames) {
@@ -414,10 +438,7 @@ async function validateApiKey(ctx: MainContext): Promise<void> {
   }
 
   if (Object.keys(apiKeys).length === 0) {
-    await throwMissingApiKeyError({
-      agent: ctx.agent,
-      repoContext: ctx.repoContext,
-    });
+    await throwMissingApiKeyError(ctx);
     // unreachable - throwMissingApiKeyError always throws
     return;
   }
@@ -427,7 +448,7 @@ async function validateApiKey(ctx: MainContext): Promise<void> {
   ctx.apiKeys = apiKeys;
 }
 
-async function runAgent(ctx: MainContext): Promise<AgentResult> {
+async function runAgent(ctx: Context): Promise<AgentResult> {
   log.info(`Running ${ctx.agentName}...`);
   // strip context from event
   const { context: _context, ...eventWithoutContext } = ctx.payload.event;

mcp/README.md

@@ -30,7 +30,7 @@ await mcp.call("gh_pullfrog/get_check_suite_logs", {
 ### review tools
 
 #### `get_review_comments`
-get all line-by-line comments for a specific pull request review.
+get all line-by-line comments and their replies for a specific pull request review.
 
 **parameters:**
 - `pull_number` (number): the pull request number
@@ -39,11 +39,11 @@ get all line-by-line comments for a specific pull request review.
 **replaces:** `gh api repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments`
 
 **returns:**
-array of review comments including:
+array of review comments including threaded replies:
 - file path, line number, comment body
 - side (LEFT/RIGHT) and position in diff
 - user, timestamps, html_url
-- in_reply_to_id for threaded comments
+- in_reply_to_id for threaded comments (replies have this set to the parent comment id)
 
 **example:**
 ```typescript

mcp/checkSuite.ts

@@ -1,94 +1,97 @@
 import { type } from "arktype";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
 
 export const GetCheckSuiteLogs = type({
   check_suite_id: type.number.describe("the id from check_suite.id"),
 });
 
-export const GetCheckSuiteLogsTool = tool({
-  name: "get_check_suite_logs",
-  description:
-    "get workflow run logs for a failed check suite. pass check_suite.id from the webhook payload.",
-  parameters: GetCheckSuiteLogs,
-  execute: contextualize(async ({ check_suite_id }, ctx) => {
-    // get workflow runs for this specific check suite
-    const workflowRuns = await ctx.octokit.paginate(
-      ctx.octokit.rest.actions.listWorkflowRunsForRepo,
-      {
-        owner: ctx.owner,
-        repo: ctx.name,
-        check_suite_id,
-        per_page: 100,
-      }
-    );
-
-    const failedRuns = workflowRuns.filter((run) => run.conclusion === "failure");
-
-    if (failedRuns.length === 0) {
-      return {
-        check_suite_id,
-        message: "no failed workflow runs found for this check suite",
-        workflow_runs: [],
-      };
-    }
-
-    // get logs for each failed run
-    const logsForRuns = await Promise.all(
-      failedRuns.map(async (run) => {
-        const jobs = await ctx.octokit.paginate(ctx.octokit.rest.actions.listJobsForWorkflowRun, {
+export function GetCheckSuiteLogsTool(ctx: Context) {
+  return tool({
+    name: "get_check_suite_logs",
+    description:
+      "get workflow run logs for a failed check suite. pass check_suite.id from the webhook payload.",
+    parameters: GetCheckSuiteLogs,
+    execute: execute(ctx, async ({ check_suite_id }) => {
+      // get workflow runs for this specific check suite
+      const workflowRuns = await ctx.octokit.paginate(
+        ctx.octokit.rest.actions.listWorkflowRunsForRepo,
+        {
           owner: ctx.owner,
           repo: ctx.name,
-          run_id: run.id,
-        });
+          check_suite_id,
+          per_page: 100,
+        }
+      );
 
-        const jobLogs = await Promise.all(
-          jobs.map(async (job) => {
-            try {
-              const logsResponse = await ctx.octokit.rest.actions.downloadJobLogsForWorkflowRun({
-                owner: ctx.owner,
-                repo: ctx.name,
-                job_id: job.id,
-              });
-
-              const logsUrl = logsResponse.url;
-              const logsText = await fetch(logsUrl).then((r) => r.text());
-
-              return {
-                job_id: job.id,
-                job_name: job.name,
-                status: job.status,
-                conclusion: job.conclusion,
-                started_at: job.started_at,
-                completed_at: job.completed_at,
-                logs: logsText,
-              };
-            } catch (error) {
-              return {
-                job_id: job.id,
-                job_name: job.name,
-                status: job.status,
-                conclusion: job.conclusion,
-                started_at: job.started_at,
-                completed_at: job.completed_at,
-                error: `failed to fetch logs: ${error}`,
-              };
-            }
-          })
-        );
+      const failedRuns = workflowRuns.filter((run) => run.conclusion === "failure");
 
+      if (failedRuns.length === 0) {
         return {
-          workflow_run_id: run.id,
-          workflow_name: run.name,
-          html_url: run.html_url,
-          conclusion: run.conclusion,
-          jobs: jobLogs,
+          check_suite_id,
+          message: "no failed workflow runs found for this check suite",
+          workflow_runs: [],
         };
-      })
-    );
+      }
 
-    return {
-      check_suite_id,
-      workflow_runs: logsForRuns,
-    };
-  }),
-});
+      // get logs for each failed run
+      const logsForRuns = await Promise.all(
+        failedRuns.map(async (run) => {
+          const jobs = await ctx.octokit.paginate(ctx.octokit.rest.actions.listJobsForWorkflowRun, {
+            owner: ctx.owner,
+            repo: ctx.name,
+            run_id: run.id,
+          });
+
+          const jobLogs = await Promise.all(
+            jobs.map(async (job) => {
+              try {
+                const logsResponse = await ctx.octokit.rest.actions.downloadJobLogsForWorkflowRun({
+                  owner: ctx.owner,
+                  repo: ctx.name,
+                  job_id: job.id,
+                });
+
+                const logsUrl = logsResponse.url;
+                const logsText = await fetch(logsUrl).then((r) => r.text());
+
+                return {
+                  job_id: job.id,
+                  job_name: job.name,
+                  status: job.status,
+                  conclusion: job.conclusion,
+                  started_at: job.started_at,
+                  completed_at: job.completed_at,
+                  logs: logsText,
+                };
+              } catch (error) {
+                return {
+                  job_id: job.id,
+                  job_name: job.name,
+                  status: job.status,
+                  conclusion: job.conclusion,
+                  started_at: job.started_at,
+                  completed_at: job.completed_at,
+                  error: `failed to fetch logs: ${error}`,
+                };
+              }
+            })
+          );
+
+          return {
+            workflow_run_id: run.id,
+            workflow_name: run.name,
+            html_url: run.html_url,
+            conclusion: run.conclusion,
+            jobs: jobLogs,
+          };
+        })
+      );
+
+      return {
+        check_suite_id,
+        workflow_runs: logsForRuns,
+      };
+    }),
+  });
+}

mcp/comment.ts

@@ -2,10 +2,11 @@ import { Octokit } from "@octokit/rest";
 import { type } from "arktype";
 import type { Payload } from "../external.ts";
 import { agentsManifest } from "../external.ts";
+import type { Context } from "../main.ts";
 import { fetchWorkflowRunInfo } from "../utils/api.ts";
 import { buildPullfrogFooter, stripExistingFooter } from "../utils/buildPullfrogFooter.ts";
 import { getGitHubInstallationToken, parseRepoContext } from "../utils/github.ts";
-import { contextualize, getMcpContext, tool } from "./shared.ts";
+import { execute, tool } from "./shared.ts";
 
 /**
  * The prefix text for the initial "leaping into action" comment.
@@ -42,58 +43,62 @@ export const Comment = type({
   body: type.string.describe("the comment body content"),
 });
 
-export const CreateCommentTool = tool({
-  name: "create_issue_comment",
-  description:
-    "Create a comment on a GitHub issue. NOTE: Do NOT use this for progress updates or status summaries - use report_progress instead, which updates the existing progress comment.",
-  parameters: Comment,
-  execute: contextualize(async ({ issueNumber, body }, ctx) => {
-    const bodyWithFooter = addFooter(body, ctx.payload);
+export function CreateCommentTool(ctx: Context) {
+  return tool({
+    name: "create_issue_comment",
+    description:
+      "Create a comment on a GitHub issue. NOTE: Do NOT use this for progress updates or status summaries - use report_progress instead, which updates the existing progress comment.",
+    parameters: Comment,
+    execute: execute(ctx, async ({ issueNumber, body }) => {
+      const bodyWithFooter = addFooter(body, ctx.payload);
 
-    const result = await ctx.octokit.rest.issues.createComment({
-      owner: ctx.owner,
-      repo: ctx.name,
-      issue_number: issueNumber,
-      body: bodyWithFooter,
-    });
+      const result = await ctx.octokit.rest.issues.createComment({
+        owner: ctx.owner,
+        repo: ctx.name,
+        issue_number: issueNumber,
+        body: bodyWithFooter,
+      });
 
-    return {
-      success: true,
-      commentId: result.data.id,
-      url: result.data.html_url,
-      body: result.data.body,
-    };
-  }),
-});
+      return {
+        success: true,
+        commentId: result.data.id,
+        url: result.data.html_url,
+        body: result.data.body,
+      };
+    }),
+  });
+}
 
 export const EditComment = type({
   commentId: type.number.describe("the ID of the comment to edit"),
   body: type.string.describe("the new comment body content"),
 });
 
-export const EditCommentTool = tool({
-  name: "edit_issue_comment",
-  description: "Edit a GitHub issue comment by its ID",
-  parameters: EditComment,
-  execute: contextualize(async ({ commentId, body }, ctx) => {
-    const bodyWithFooter = addFooter(body, ctx.payload);
+export function EditCommentTool(ctx: Context) {
+  return tool({
+    name: "edit_issue_comment",
+    description: "Edit a GitHub issue comment by its ID",
+    parameters: EditComment,
+    execute: execute(ctx, async ({ commentId, body }) => {
+      const bodyWithFooter = addFooter(body, ctx.payload);
 
-    const result = await ctx.octokit.rest.issues.updateComment({
-      owner: ctx.owner,
-      repo: ctx.name,
-      comment_id: commentId,
-      body: bodyWithFooter,
-    });
+      const result = await ctx.octokit.rest.issues.updateComment({
+        owner: ctx.owner,
+        repo: ctx.name,
+        comment_id: commentId,
+        body: bodyWithFooter,
+      });
 
-    return {
-      success: true,
-      commentId: result.data.id,
-      url: result.data.html_url,
-      body: result.data.body,
-      updatedAt: result.data.updated_at,
-    };
-  }),
-});
+      return {
+        success: true,
+        commentId: result.data.id,
+        url: result.data.html_url,
+        body: result.data.body,
+        updatedAt: result.data.updated_at,
+      };
+    }),
+  });
+}
 
 /**
  * Get progress comment ID from environment variable.
@@ -141,7 +146,10 @@ export const ReportProgress = type({
  * Can be called directly without going through the MCP tool interface.
  * Returns result data if successful, undefined if comment cannot be created.
  */
-export async function reportProgress({ body }: { body: string }): Promise<
+export async function reportProgress(
+  ctx: Context,
+  { body }: { body: string }
+): Promise<
   | {
       commentId: number;
       url: string;
@@ -150,8 +158,6 @@ export async function reportProgress({ body }: { body: string }): Promise<
     }
   | undefined
 > {
-  const ctx = getMcpContext();
-
   const bodyWithFooter = addFooter(body, ctx.payload);
   const existingCommentId = getProgressCommentId();
 
@@ -177,7 +183,8 @@ export async function reportProgress({ body }: { body: string }): Promise<
   // no existing comment - create one
   const issueNumber = ctx.payload.event.issue_number;
   if (issueNumber === undefined) {
-    throw new Error("cannot create progress comment: no issue_number found in the payload event");
+    // cannot create comment without issue_number (e.g., workflow_dispatch events)
+    return undefined;
   }
 
   const result = await ctx.octokit.rest.issues.createComment({
@@ -199,20 +206,32 @@ export async function reportProgress({ body }: { body: string }): Promise<
   };
 }
 
-export const ReportProgressTool = tool({
-  name: "report_progress",
-  description:
-    "Share progress on the associated GitHub issue/PR. Call this to post updates as you work. The first call creates a comment, subsequent calls update it. Use this throughout your work to keep stakeholders informed.",
-  parameters: ReportProgress,
-  execute: contextualize(async ({ body }) => {
-    const result = await reportProgress({ body });
+export function ReportProgressTool(ctx: Context) {
+  return tool({
+    name: "report_progress",
+    description:
+      "Share progress on the associated GitHub issue/PR. Call this to post updates as you work. The first call creates a comment, subsequent calls update it. Use this throughout your work to keep stakeholders informed.",
+    parameters: ReportProgress,
+    execute: execute(ctx, async ({ body }) => {
+      const result = await reportProgress(ctx, { body });
 
-    return {
-      success: true,
-      ...result,
-    };
-  }),
-});
+      if (!result) {
+        // gracefully handle case where no comment can be created
+        // this happens for workflow_dispatch events or when there's no associated issue/PR
+        return {
+          success: false,
+          message:
+            "cannot create progress comment: no issue_number found in the payload event. this may occur for workflow_dispatch events or when there is no associated issue/PR. if you need to comment on a specific issue or PR, use create_issue_comment with an explicit issueNumber.",
+        };
+      }
+
+      return {
+        success: true,
+        ...result,
+      };
+    }),
+  });
+}
 
 /**
  * Check if the progress comment was updated during execution
@@ -225,14 +244,12 @@ export function wasProgressCommentUpdated(): boolean {
  * Delete the progress comment if it exists.
  * Used after submitting a PR review since the review body contains all necessary info.
  */
-export async function deleteProgressComment(): Promise<boolean> {
+export async function deleteProgressComment(ctx: Context): Promise<boolean> {
   const existingCommentId = getProgressCommentId();
   if (!existingCommentId) {
     return false;
   }
 
-  const ctx = getMcpContext();
-
   await ctx.octokit.rest.issues.deleteComment({
     owner: ctx.owner,
     repo: ctx.name,
@@ -310,16 +327,6 @@ export async function ensureProgressCommentUpdated(payload?: Payload): Promise<v
     return;
   }
 
-  // try to get payload from MCP context if available, otherwise use provided payload
-  let resolvedPayload: Payload | undefined;
-  try {
-    const ctx = getMcpContext();
-    resolvedPayload = ctx.payload;
-  } catch {
-    // MCP context not initialized, use provided payload
-    resolvedPayload = payload;
-  }
-
   const runId = process.env.GITHUB_RUN_ID;
   const workflowRunLink = runId
     ? `[workflow](https://github.com/${repoContext.owner}/${repoContext.name}/actions/runs/${runId})`
@@ -330,7 +337,7 @@ export async function ensureProgressCommentUpdated(payload?: Payload): Promise<v
 The workflow encountered an error before any progress could be reported. Please check the ${workflowRunLink} for details.`;
 
   // add footer if we have payload, otherwise use plain message
-  const body = resolvedPayload ? addFooter(errorMessage, resolvedPayload) : errorMessage;
+  const body = payload ? addFooter(errorMessage, payload) : errorMessage;
 
   await octokit.rest.issues.updateComment({
     owner: repoContext.owner,
@@ -348,28 +355,30 @@ export const ReplyToReviewComment = type({
   ),
 });
 
-export const ReplyToReviewCommentTool = tool({
-  name: "reply_to_review_comment",
-  description:
-    "Reply to a PR review comment thread. Call this for EACH comment you address. Keep replies extremely brief (1 sentence max).",
-  parameters: ReplyToReviewComment,
-  execute: contextualize(async ({ pull_number, comment_id, body }, ctx) => {
-    const bodyWithFooter = addFooter(body, ctx.payload);
+export function ReplyToReviewCommentTool(ctx: Context) {
+  return tool({
+    name: "reply_to_review_comment",
+    description:
+      "Reply to a PR review comment thread. Call this for EACH comment you address. Keep replies extremely brief (1 sentence max).",
+    parameters: ReplyToReviewComment,
+    execute: execute(ctx, async ({ pull_number, comment_id, body }) => {
+      const bodyWithFooter = addFooter(body, ctx.payload);
 
-    const result = await ctx.octokit.rest.pulls.createReplyForReviewComment({
-      owner: ctx.owner,
-      repo: ctx.name,
-      pull_number,
-      comment_id,
-      body: bodyWithFooter,
-    });
+      const result = await ctx.octokit.rest.pulls.createReplyForReviewComment({
+        owner: ctx.owner,
+        repo: ctx.name,
+        pull_number,
+        comment_id,
+        body: bodyWithFooter,
+      });
 
-    return {
-      success: true,
-      commentId: result.data.id,
-      url: result.data.html_url,
-      body: result.data.body,
-      in_reply_to_id: result.data.in_reply_to_id,
-    };
-  }),
-});
+      return {
+        success: true,
+        commentId: result.data.id,
+        url: result.data.html_url,
+        body: result.data.body,
+        in_reply_to_id: result.data.in_reply_to_id,
+      };
+    }),
+  });
+}

mcp/debug.ts

@@ -1,7 +1,6 @@
 import { type } from "arktype";
 import { $ } from "../utils/shell.ts";
-import type { ToolResult } from "./shared.ts";
-import { tool } from "./shared.ts";
+import { handleToolError, handleToolSuccess, tool, type ToolResult } from "./shared.ts";
 
 export const DebugShellCommand = type({});
 
@@ -13,33 +12,13 @@ export const DebugShellCommandTool = tool({
   execute: async (): Promise<ToolResult> => {
     try {
       const result = $("git", ["status"]);
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                success: true,
-                command: "git status",
-                output: result.trim(),
-              },
-              null,
-              2
-            ),
-          },
-        ],
-      };
+      return handleToolSuccess({
+        success: true,
+        command: "git status",
+        output: result.trim(),
+      });
     } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-        isError: true,
-      };
+      return handleToolError(error);
     }
   },
 });

mcp/files.ts

@@ -1,6 +1,6 @@
 import { type } from "arktype";
 import { $ } from "../utils/shell.ts";
-import { contextualize, tool } from "./shared.ts";
+import { handleToolError, handleToolSuccess, tool, type ToolResult } from "./shared.ts";
 
 export const ListFiles = type({
   path: type.string
@@ -8,12 +8,13 @@ export const ListFiles = type({
     .default("."),
 });
 
+// static tool - doesn't need ctx, just runs git/find commands
 export const ListFilesTool = tool({
   name: "list_files",
   description:
     "List files in the repository using git ls-files. Useful for discovering the file structure and locating files.",
   parameters: ListFiles,
-  execute: contextualize(async ({ path }) => {
+  execute: async ({ path }: { path?: string }): Promise<ToolResult> => {
     try {
       // Use git ls-files to list tracked files
       // This respects .gitignore and gives a clean list of source files
@@ -30,19 +31,15 @@ export const ListFilesTool = tool({
           [pathStr, "-maxdepth", "3", "-not", "-path", "*/.*", "-type", "f"],
           { log: false }
         );
-        return {
+        return handleToolSuccess({
           files: findOutput.split("\n").filter((f) => f.trim() !== ""),
           method: "find",
-        };
+        });
       }
 
-      return { files, method: "git" };
+      return handleToolSuccess({ files, method: "git" });
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return {
-        error: `Failed to list files: ${errorMessage}`,
-        hint: "Try using a specific path if the repository root is not the current directory.",
-      };
+      return handleToolError(error);
     }
-  }),
+  },
 });

mcp/git.ts

@@ -1,55 +1,65 @@
 import { type } from "arktype";
+import type { Context } from "../main.ts";
 import { log } from "../utils/cli.ts";
 import { containsSecrets } from "../utils/secrets.ts";
 import { $ } from "../utils/shell.ts";
-import { contextualize, tool } from "./shared.ts";
+import { execute, tool } from "./shared.ts";
 
-export const CreateBranch = type({
-  branchName: type.string.describe(
-    "The name of the branch to create (e.g., 'pullfrog/123-fix-bug')"
-  ),
-  baseBranch: type.string.describe("The base branch to create from (e.g., 'main')").default("main"),
-});
+export function CreateBranchTool(ctx: Context) {
+  const defaultBranch = ctx.repo.default_branch || "main";
 
-export const CreateBranchTool = tool({
-  name: "create_branch",
-  description:
-    "Create a new git branch from the specified base branch. The branch will be created locally and pushed to the remote repository.",
-  parameters: CreateBranch,
-  execute: contextualize(async ({ branchName, baseBranch }) => {
-    // validate branch name for secrets
-    if (containsSecrets(branchName)) {
-      throw new Error(
-        "Branch creation blocked: secrets detected in branch name. " +
-          "Please remove any sensitive information (API keys, tokens, passwords) before creating a branch."
-      );
-    }
+  const CreateBranch = type({
+    branchName: type.string.describe(
+      "The name of the branch to create (e.g., 'pullfrog/123-fix-bug')"
+    ),
+    baseBranch: type.string
+      .describe(`The base branch to create from (defaults to '${defaultBranch}')`)
+      .default(defaultBranch),
+  });
 
-    log.info(`Creating branch ${branchName} from ${baseBranch}`);
+  return tool({
+    name: "create_branch",
+    description:
+      "Create a new git branch from the specified base branch. The branch will be created locally and pushed to the remote repository.",
+    parameters: CreateBranch,
+    execute: execute(ctx, async ({ branchName, baseBranch }) => {
+      // baseBranch should always be defined due to default, but TypeScript needs help
+      const resolvedBaseBranch = baseBranch || ctx.repo.default_branch || "main";
 
-    // fetch base branch to ensure we're up to date
-    $("git", ["fetch", "origin", baseBranch, "--depth=1"]);
+      // validate branch name for secrets
+      if (containsSecrets(branchName)) {
+        throw new Error(
+          "Branch creation blocked: secrets detected in branch name. " +
+            "Please remove any sensitive information (API keys, tokens, passwords) before creating a branch."
+        );
+      }
 
-    // checkout base branch, ensuring it matches the remote version
-    // -B creates or resets the branch to match origin/baseBranch
-    $("git", ["checkout", "-B", baseBranch, `origin/${baseBranch}`]);
+      log.info(`Creating branch ${branchName} from ${resolvedBaseBranch}`);
 
-    // create and checkout new branch
-    $("git", ["checkout", "-b", branchName]);
+      // fetch base branch to ensure we're up to date
+      $("git", ["fetch", "origin", resolvedBaseBranch, "--depth=1"]);
 
-    // push branch to remote (set upstream)
-    $("git", ["push", "-u", "origin", branchName]);
+      // checkout base branch, ensuring it matches the remote version
+      // -B creates or resets the branch to match origin/baseBranch
+      $("git", ["checkout", "-B", resolvedBaseBranch, `origin/${resolvedBaseBranch}`]);
 
-    log.info(`Successfully created and pushed branch ${branchName}`);
+      // create and checkout new branch
+      $("git", ["checkout", "-b", branchName]);
 
-    return {
-      success: true,
-      branchName,
-      baseBranch,
-      message: `Branch ${branchName} created from ${baseBranch} and pushed to remote`,
-    };
-  }),
-});
+      // push branch to remote (set upstream)
+      $("git", ["push", "-u", "origin", branchName]);
+
+      log.info(`Successfully created and pushed branch ${branchName}`);
+
+      return {
+        success: true,
+        branchName,
+        baseBranch: resolvedBaseBranch,
+        message: `Branch ${branchName} created from ${resolvedBaseBranch} and pushed to remote`,
+      };
+    }),
+  });
+}
 
 export const CommitFiles = type({
   message: type.string.describe("The commit message"),
@@ -60,67 +70,69 @@ export const CommitFiles = type({
     ),
 });
 
-export const CommitFilesTool = tool({
-  name: "commit_files",
-  description:
-    "Stage and commit files with a commit message. If files array is empty, commits all staged changes. The commit will be attributed to the correct bot account.",
-  parameters: CommitFiles,
-  execute: contextualize(async ({ message, files }) => {
-    // validate commit message for secrets
-    if (containsSecrets(message)) {
-      throw new Error(
-        "Commit blocked: secrets detected in commit message. " +
-          "Please remove any sensitive information (API keys, tokens, passwords) before committing."
-      );
-    }
+export function CommitFilesTool(ctx: Context) {
+  return tool({
+    name: "commit_files",
+    description:
+      "Stage and commit files with a commit message. If files array is empty, commits all staged changes. The commit will be attributed to the correct bot account.",
+    parameters: CommitFiles,
+    execute: execute(ctx, async ({ message, files }) => {
+      // validate commit message for secrets
+      if (containsSecrets(message)) {
+        throw new Error(
+          "Commit blocked: secrets detected in commit message. " +
+            "Please remove any sensitive information (API keys, tokens, passwords) before committing."
+        );
+      }
 
-    // validate files for secrets if provided
-    if (files.length > 0) {
-      for (const file of files) {
-        try {
-          // try to read file content - if it exists, check for secrets
-          const content = $("cat", [file], { log: false });
-          if (containsSecrets(content)) {
-            throw new Error(
-              `Commit blocked: secrets detected in file ${file}. ` +
-                "Please remove any sensitive information (API keys, tokens, passwords) before committing."
-            );
+      // validate files for secrets if provided
+      if (files.length > 0) {
+        for (const file of files) {
+          try {
+            // try to read file content - if it exists, check for secrets
+            const content = $("cat", [file], { log: false });
+            if (containsSecrets(content)) {
+              throw new Error(
+                `Commit blocked: secrets detected in file ${file}. ` +
+                  "Please remove any sensitive information (API keys, tokens, passwords) before committing."
+              );
+            }
+          } catch (error) {
+            // if error is about secrets, re-throw it
+            if (error instanceof Error && error.message.includes("Commit blocked")) {
+              throw error;
+            }
+            // if file doesn't exist (cat fails), that's ok - it will be created by git add
+            // other errors are also ok - git add will handle them
           }
-        } catch (error) {
-          // if error is about secrets, re-throw it
-          if (error instanceof Error && error.message.includes("Commit blocked")) {
-            throw error;
-          }
-          // if file doesn't exist (cat fails), that's ok - it will be created by git add
-          // other errors are also ok - git add will handle them
         }
       }
-    }
 
-    const currentBranch = $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
-    log.info(`Committing files on branch ${currentBranch}`);
+      const currentBranch = $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
+      log.info(`Committing files on branch ${currentBranch}`);
 
-    // stage files if provided, otherwise stage all changes
-    if (files.length > 0) {
-      $("git", ["add", ...files]);
-    } else {
-      $("git", ["add", "."]);
-    }
+      // stage files if provided, otherwise stage all changes
+      if (files.length > 0) {
+        $("git", ["add", ...files]);
+      } else {
+        $("git", ["add", "."]);
+      }
 
-    // commit with message
-    $("git", ["commit", "-m", message]);
+      // commit with message
+      $("git", ["commit", "-m", message]);
 
-    const commitSha = $("git", ["rev-parse", "HEAD"], { log: false });
-    log.info(`Successfully committed: ${commitSha.substring(0, 7)}`);
+      const commitSha = $("git", ["rev-parse", "HEAD"], { log: false });
+      log.info(`Successfully committed: ${commitSha.substring(0, 7)}`);
 
-    return {
-      success: true,
-      commitSha,
-      branch: currentBranch,
-      message: `Committed ${files.length > 0 ? files.length + " file(s)" : "all changes"} with message: ${message}`,
-    };
-  }),
-});
+      return {
+        success: true,
+        commitSha,
+        branch: currentBranch,
+        message: `Committed ${files.length > 0 ? files.length + " file(s)" : "all changes"} with message: ${message}`,
+      };
+    }),
+  });
+}
 
 export const PushBranch = type({
   branchName: type.string
@@ -129,27 +141,36 @@ export const PushBranch = type({
   force: type.boolean.describe("Force push (use with caution)").default(false),
 });
 
-export const PushBranchTool = tool({
-  name: "push_branch",
-  description:
-    "Push the current branch (or specified branch) to the remote repository. Never force push unless explicitly requested.",
-  parameters: PushBranch,
-  execute: contextualize(async ({ branchName, force }) => {
-    const branch = branchName || $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
+export function PushBranchTool(ctx: Context) {
+  const remote = ctx.pushRemote;
 
-    if (force) {
-      log.warning(`Force pushing branch ${branch} - this will overwrite remote history`);
-      $("git", ["push", "--force", "origin", branch]);
-    } else {
-      log.info(`Pushing branch ${branch} to remote`);
-      $("git", ["push", "origin", branch]);
-    }
+  return tool({
+    name: "push_branch",
+    description:
+      "Push the current branch (or specified branch) to the remote repository. Never force push unless explicitly requested.",
+    parameters: PushBranch,
+    execute: execute(ctx, async ({ branchName, force }) => {
+      const branch = branchName || $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
 
-    return {
-      success: true,
-      branch,
-      force,
-      message: `Successfully pushed branch ${branch} to remote`,
-    };
-  }),
-});
+      // skip -u flag when pushing to URL (can't set upstream without a remote name)
+      const isUrl = remote.startsWith("https://");
+      const args = force
+        ? ["push", "--force", ...(isUrl ? [] : ["-u"]), remote, branch]
+        : ["push", ...(isUrl ? [] : ["-u"]), remote, branch];
+
+      log.info(`Pushing branch ${branch} to ${isUrl ? "(fork URL)" : remote}`);
+      if (force) {
+        log.warning(`Force pushing - this will overwrite remote history`);
+      }
+      $("git", args);
+
+      return {
+        success: true,
+        branch,
+        remote: isUrl ? "(fork URL)" : remote,
+        force,
+        message: `Successfully pushed branch ${branch}`,
+      };
+    }),
+  });
+}

mcp/issue.ts

@@ -1,5 +1,6 @@
 import { type } from "arktype";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
 
 export const Issue = type({
   title: type.string.describe("the title of the issue"),
@@ -14,29 +15,31 @@ export const Issue = type({
     .optional(),
 });
 
-export const IssueTool = tool({
-  name: "create_issue",
-  description: "Create a new GitHub issue",
-  parameters: Issue,
-  execute: contextualize(async ({ title, body, labels, assignees }, ctx) => {
-    const result = await ctx.octokit.rest.issues.create({
-      owner: ctx.owner,
-      repo: ctx.name,
-      title: title,
-      body: body,
-      labels: labels ?? [],
-      assignees: assignees ?? [],
-    });
+export function IssueTool(ctx: Context) {
+  return tool({
+    name: "create_issue",
+    description: "Create a new GitHub issue",
+    parameters: Issue,
+    execute: execute(ctx, async ({ title, body, labels, assignees }) => {
+      const result = await ctx.octokit.rest.issues.create({
+        owner: ctx.owner,
+        repo: ctx.name,
+        title: title,
+        body: body,
+        labels: labels ?? [],
+        assignees: assignees ?? [],
+      });
 
-    return {
-      success: true,
-      issueId: result.data.id,
-      number: result.data.number,
-      url: result.data.html_url,
-      title: result.data.title,
-      state: result.data.state,
-      labels: result.data.labels?.map((label) => (typeof label === "string" ? label : label.name)),
-      assignees: result.data.assignees?.map((assignee) => assignee.login),
-    };
-  }),
-});
+      return {
+        success: true,
+        issueId: result.data.id,
+        number: result.data.number,
+        url: result.data.html_url,
+        title: result.data.title,
+        state: result.data.state,
+        labels: result.data.labels?.map((label) => (typeof label === "string" ? label : label.name)),
+        assignees: result.data.assignees?.map((assignee) => assignee.login),
+      };
+    }),
+  });
+}

mcp/issueComments.ts

@@ -1,35 +1,38 @@
 import { type } from "arktype";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
 
 export const GetIssueComments = type({
   issue_number: type.number.describe("The issue number to get comments for"),
 });
 
-export const GetIssueCommentsTool = tool({
-  name: "get_issue_comments",
-  description:
-    "Get all comments for a GitHub issue. Returns all comments including the issue body and all subsequent discussion comments.",
-  parameters: GetIssueComments,
-  execute: contextualize(async ({ issue_number }, ctx) => {
-    const comments = await ctx.octokit.paginate(ctx.octokit.rest.issues.listComments, {
-      owner: ctx.owner,
-      repo: ctx.name,
-      issue_number,
-    });
+export function GetIssueCommentsTool(ctx: Context) {
+  return tool({
+    name: "get_issue_comments",
+    description:
+      "Get all comments for a GitHub issue. Returns all comments including the issue body and all subsequent discussion comments.",
+    parameters: GetIssueComments,
+    execute: execute(ctx, async ({ issue_number }) => {
+      const comments = await ctx.octokit.paginate(ctx.octokit.rest.issues.listComments, {
+        owner: ctx.owner,
+        repo: ctx.name,
+        issue_number,
+      });
 
-    return {
-      issue_number,
-      comments: comments.map((comment) => ({
-        id: comment.id,
-        body: comment.body,
-        user: comment.user?.login,
-        created_at: comment.created_at,
-        updated_at: comment.updated_at,
-        html_url: comment.html_url,
-        author_association: comment.author_association,
-        reactions: comment.reactions,
-      })),
-      count: comments.length,
-    };
-  }),
-});
+      return {
+        issue_number,
+        comments: comments.map((comment) => ({
+          id: comment.id,
+          body: comment.body,
+          user: comment.user?.login,
+          created_at: comment.created_at,
+          updated_at: comment.updated_at,
+          html_url: comment.html_url,
+          author_association: comment.author_association,
+          reactions: comment.reactions,
+        })),
+        count: comments.length,
+      };
+    }),
+  });
+}

mcp/issueEvents.ts

@@ -1,93 +1,96 @@
 import { type } from "arktype";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
 
 export const GetIssueEvents = type({
   issue_number: type.number.describe("The issue number to get events for"),
 });
 
-export const GetIssueEventsTool = tool({
-  name: "get_issue_events",
-  description:
-    "Get timeline events for a GitHub issue that aren't reflected in the current state. Returns cross-references to other issues/PRs and commit references. Note: current labels, assignees, state, and milestone are already available via get_issue.",
-  parameters: GetIssueEvents,
-  execute: contextualize(async ({ issue_number }, ctx) => {
-    const events = await ctx.octokit.paginate(ctx.octokit.rest.issues.listEventsForTimeline, {
-      owner: ctx.owner,
-      repo: ctx.name,
-      issue_number,
-    });
+export function GetIssueEventsTool(ctx: Context) {
+  return tool({
+    name: "get_issue_events",
+    description:
+      "Get timeline events for a GitHub issue that aren't reflected in the current state. Returns cross-references to other issues/PRs and commit references. Note: current labels, assignees, state, and milestone are already available via get_issue.",
+    parameters: GetIssueEvents,
+    execute: execute(ctx, async ({ issue_number }) => {
+      const events = await ctx.octokit.paginate(ctx.octokit.rest.issues.listEventsForTimeline, {
+        owner: ctx.owner,
+        repo: ctx.name,
+        issue_number,
+      });
 
-    // Only include events not reflected in current issue state (get_issue already has labels, assignees, state, etc.)
-    // Keep only relationship/reference events that show connections to other issues/PRs/commits
-    const relevantEventTypes = new Set(["cross_referenced", "referenced"]);
+      // Only include events not reflected in current issue state (get_issue already has labels, assignees, state, etc.)
+      // Keep only relationship/reference events that show connections to other issues/PRs/commits
+      const relevantEventTypes = new Set(["cross_referenced", "referenced"]);
 
-    const parsedEvents = events.flatMap((event) => {
-      // Filter to only events with an 'event' property and relevant types
-      if (!("event" in event) || !relevantEventTypes.has(event.event)) {
-        return [];
-      }
+      const parsedEvents = events.flatMap((event) => {
+        // Filter to only events with an 'event' property and relevant types
+        if (!("event" in event) || !relevantEventTypes.has(event.event)) {
+          return [];
+        }
 
-      const baseEvent: Record<string, any> = {
-        event: event.event,
+        const baseEvent: Record<string, any> = {
+          event: event.event,
+        };
+
+        // Common fields
+        if ("id" in event) {
+          baseEvent.id = event.id;
+        }
+        if ("actor" in event && event.actor) {
+          baseEvent.actor = event.actor.login;
+        } else if ("user" in event && event.user) {
+          baseEvent.actor = event.user.login;
+        }
+        if ("created_at" in event) {
+          baseEvent.created_at = event.created_at;
+        }
+
+        // Event-specific data
+        if (event.event === "cross_referenced") {
+          if ("source" in event && event.source) {
+            const source = event.source as {
+              type?: string;
+              issue?: { number: number; title: string; html_url: string };
+              pull_request?: { number: number; title: string; html_url: string };
+            };
+            baseEvent.source = {
+              type: source.type,
+              issue: source.issue
+                ? {
+                    number: source.issue.number,
+                    title: source.issue.title,
+                    html_url: source.issue.html_url,
+                  }
+                : null,
+              pull_request: source.pull_request
+                ? {
+                    number: source.pull_request.number,
+                    title: source.pull_request.title,
+                    html_url: source.pull_request.html_url,
+                  }
+                : null,
+            };
+          }
+        }
+
+        if (event.event === "referenced") {
+          if ("commit_id" in event) {
+            baseEvent.commit_id = event.commit_id;
+          }
+          if ("commit_url" in event) {
+            baseEvent.commit_url = event.commit_url;
+          }
+        }
+
+        return [baseEvent];
+      });
+
+      return {
+        issue_number,
+        events: parsedEvents,
+        count: parsedEvents.length,
       };
-
-      // Common fields
-      if ("id" in event) {
-        baseEvent.id = event.id;
-      }
-      if ("actor" in event && event.actor) {
-        baseEvent.actor = event.actor.login;
-      } else if ("user" in event && event.user) {
-        baseEvent.actor = event.user.login;
-      }
-      if ("created_at" in event) {
-        baseEvent.created_at = event.created_at;
-      }
-
-      // Event-specific data
-      if (event.event === "cross_referenced") {
-        if ("source" in event && event.source) {
-          const source = event.source as {
-            type?: string;
-            issue?: { number: number; title: string; html_url: string };
-            pull_request?: { number: number; title: string; html_url: string };
-          };
-          baseEvent.source = {
-            type: source.type,
-            issue: source.issue
-              ? {
-                  number: source.issue.number,
-                  title: source.issue.title,
-                  html_url: source.issue.html_url,
-                }
-              : null,
-            pull_request: source.pull_request
-              ? {
-                  number: source.pull_request.number,
-                  title: source.pull_request.title,
-                  html_url: source.pull_request.html_url,
-                }
-              : null,
-          };
-        }
-      }
-
-      if (event.event === "referenced") {
-        if ("commit_id" in event) {
-          baseEvent.commit_id = event.commit_id;
-        }
-        if ("commit_url" in event) {
-          baseEvent.commit_url = event.commit_url;
-        }
-      }
-
-      return [baseEvent];
-    });
-
-    return {
-      issue_number,
-      events: parsedEvents,
-      count: parsedEvents.length,
-    };
-  }),
-});
+    }),
+  });
+}

mcp/issueInfo.ts

@@ -1,55 +1,58 @@
 import { type } from "arktype";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
 
 export const IssueInfo = type({
   issue_number: type.number.describe("The issue number to fetch"),
 });
 
-export const IssueInfoTool = tool({
-  name: "get_issue",
-  description: "Retrieve GitHub issue information by issue number",
-  parameters: IssueInfo,
-  execute: contextualize(async ({ issue_number }, ctx) => {
-    const issue = await ctx.octokit.rest.issues.get({
-      owner: ctx.owner,
-      repo: ctx.name,
-      issue_number,
-    });
+export function IssueInfoTool(ctx: Context) {
+  return tool({
+    name: "get_issue",
+    description: "Retrieve GitHub issue information by issue number",
+    parameters: IssueInfo,
+    execute: execute(ctx, async ({ issue_number }) => {
+      const issue = await ctx.octokit.rest.issues.get({
+        owner: ctx.owner,
+        repo: ctx.name,
+        issue_number,
+      });
 
-    const data = issue.data;
+      const data = issue.data;
 
-    const hints: string[] = [];
-    if (data.comments > 0) {
-      hints.push("use get_issue_comments to retrieve all comments for this issue");
-    }
-    hints.push(
-      "use get_issue_events to retrieve cross-references and commit references (relationships not reflected in current state)"
-    );
+      const hints: string[] = [];
+      if (data.comments > 0) {
+        hints.push("use get_issue_comments to retrieve all comments for this issue");
+      }
+      hints.push(
+        "use get_issue_events to retrieve cross-references and commit references (relationships not reflected in current state)"
+      );
 
-    return {
-      number: data.number,
-      url: data.html_url,
-      title: data.title,
-      body: data.body,
-      state: data.state,
-      locked: data.locked,
-      labels: data.labels?.map((label) => (typeof label === "string" ? label : label.name)),
-      assignees: data.assignees?.map((assignee) => assignee.login),
-      user: data.user?.login,
-      created_at: data.created_at,
-      updated_at: data.updated_at,
-      closed_at: data.closed_at,
-      comments: data.comments,
-      milestone: data.milestone?.title,
-      pull_request: data.pull_request
-        ? {
-            url: data.pull_request.url,
-            html_url: data.pull_request.html_url,
-            diff_url: data.pull_request.diff_url,
-            patch_url: data.pull_request.patch_url,
-          }
-        : null,
-      hints,
-    };
-  }),
-});
+      return {
+        number: data.number,
+        url: data.html_url,
+        title: data.title,
+        body: data.body,
+        state: data.state,
+        locked: data.locked,
+        labels: data.labels?.map((label) => (typeof label === "string" ? label : label.name)),
+        assignees: data.assignees?.map((assignee) => assignee.login),
+        user: data.user?.login,
+        created_at: data.created_at,
+        updated_at: data.updated_at,
+        closed_at: data.closed_at,
+        comments: data.comments,
+        milestone: data.milestone?.title,
+        pull_request: data.pull_request
+          ? {
+              url: data.pull_request.url,
+              html_url: data.pull_request.html_url,
+              diff_url: data.pull_request.diff_url,
+              patch_url: data.pull_request.patch_url,
+            }
+          : null,
+        hints,
+      };
+    }),
+  });
+}

mcp/labels.ts

@@ -1,27 +1,30 @@
 import { type } from "arktype";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
 
 export const AddLabelsParams = type({
   issue_number: type.number.describe("the issue or PR number to add labels to"),
   labels: type.string.array().atLeastLength(1).describe("array of label names to add"),
 });
 
-export const AddLabelsTool = tool({
-  name: "add_labels",
-  description:
-    "Add labels to a GitHub issue or pull request. Only use labels that already exist in the repository.",
-  parameters: AddLabelsParams,
-  execute: contextualize(async ({ issue_number, labels }, ctx) => {
-    const result = await ctx.octokit.rest.issues.addLabels({
-      owner: ctx.owner,
-      repo: ctx.name,
-      issue_number,
-      labels,
-    });
+export function AddLabelsTool(ctx: Context) {
+  return tool({
+    name: "add_labels",
+    description:
+      "Add labels to a GitHub issue or pull request. Only use labels that already exist in the repository.",
+    parameters: AddLabelsParams,
+    execute: execute(ctx, async ({ issue_number, labels }) => {
+      const result = await ctx.octokit.rest.issues.addLabels({
+        owner: ctx.owner,
+        repo: ctx.name,
+        issue_number,
+        labels,
+      });
 
-    return {
-      success: true,
-      labels: result.data.map((label) => label.name),
-    };
-  }),
-});
+      return {
+        success: true,
+        labels: result.data.map((label) => label.name),
+      };
+    }),
+  });
+}

mcp/pr.ts

@@ -1,8 +1,9 @@
 import { type } from "arktype";
+import type { Context } from "../main.ts";
 import { log } from "../utils/cli.ts";
 import { containsSecrets } from "../utils/secrets.ts";
 import { $ } from "../utils/shell.ts";
-import { contextualize, tool } from "./shared.ts";
+import { execute, tool } from "./shared.ts";
 
 export const PullRequest = type({
   title: type.string.describe("the title of the pull request"),
@@ -10,48 +11,50 @@ export const PullRequest = type({
   base: type.string.describe("the base branch to merge into (e.g., 'main')"),
 });
 
-export const PullRequestTool = tool({
-  name: "create_pull_request",
-  description: "Create a pull request from the current branch",
-  parameters: PullRequest,
-  execute: contextualize(async ({ title, body, base }, ctx) => {
-    const currentBranch = $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
-    log.info(`Current branch: ${currentBranch}`);
+export function PullRequestTool(ctx: Context) {
+  return tool({
+    name: "create_pull_request",
+    description: "Create a pull request from the current branch",
+    parameters: PullRequest,
+    execute: execute(ctx, async ({ title, body, base }) => {
+      const currentBranch = $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
+      log.info(`Current branch: ${currentBranch}`);
 
-    // validate PR title and body for secrets
-    if (containsSecrets(title) || containsSecrets(body)) {
-      throw new Error(
-        "PR creation blocked: secrets detected in PR title or body. " +
-          "Please remove any sensitive information (API keys, tokens, passwords) before creating a PR."
-      );
-    }
+      // validate PR title and body for secrets
+      if (containsSecrets(title) || containsSecrets(body)) {
+        throw new Error(
+          "PR creation blocked: secrets detected in PR title or body. " +
+            "Please remove any sensitive information (API keys, tokens, passwords) before creating a PR."
+        );
+      }
 
-    // validate all changes that would be in the PR (from base to HEAD)
-    const diff = $("git", ["diff", `origin/${base}...HEAD`], { log: false });
-    if (containsSecrets(diff)) {
-      throw new Error(
-        "PR creation blocked: secrets detected in changes. " +
-          "Please remove any sensitive information (API keys, tokens, passwords) before creating a PR."
-      );
-    }
+      // validate all changes that would be in the PR (from base to HEAD)
+      const diff = $("git", ["diff", `origin/${base}...HEAD`], { log: false });
+      if (containsSecrets(diff)) {
+        throw new Error(
+          "PR creation blocked: secrets detected in changes. " +
+            "Please remove any sensitive information (API keys, tokens, passwords) before creating a PR."
+        );
+      }
 
-    const result = await ctx.octokit.rest.pulls.create({
-      owner: ctx.owner,
-      repo: ctx.name,
-      title: title,
-      body: body,
-      head: currentBranch,
-      base: base,
-    });
+      const result = await ctx.octokit.rest.pulls.create({
+        owner: ctx.owner,
+        repo: ctx.name,
+        title: title,
+        body: body,
+        head: currentBranch,
+        base: base,
+      });
 
-    return {
-      success: true,
-      pullRequestId: result.data.id,
-      number: result.data.number,
-      url: result.data.html_url,
-      title: result.data.title,
-      head: result.data.head.ref,
-      base: result.data.base.ref,
-    };
-  }),
-});
+      return {
+        success: true,
+        pullRequestId: result.data.id,
+        number: result.data.number,
+        url: result.data.html_url,
+        title: result.data.title,
+        head: result.data.head.ref,
+        base: result.data.base.ref,
+      };
+    }),
+  });
+}

mcp/prInfo.ts

@@ -1,69 +1,40 @@
 import { type } from "arktype";
-import { log } from "../utils/cli.ts";
-import { $ } from "../utils/shell.ts";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
 
 export const PullRequestInfo = type({
   pull_number: type.number.describe("The pull request number to fetch"),
 });
 
-export const PullRequestInfoTool = tool({
-  name: "get_pull_request",
-  description: "Retrieve PR information. Automatically fetches and checks out the PR branch.",
-  parameters: PullRequestInfo,
-  execute: contextualize(async ({ pull_number }, ctx) => {
-    const pr = await ctx.octokit.rest.pulls.get({
-      owner: ctx.owner,
-      repo: ctx.name,
-      pull_number,
-    });
+export function PullRequestInfoTool(ctx: Context) {
+  return tool({
+    name: "get_pull_request",
+    description:
+      "Retrieve PR information (metadata only). PR branch is already checked out during setup.",
+    parameters: PullRequestInfo,
+    execute: execute(ctx, async ({ pull_number }) => {
+      const pr = await ctx.octokit.rest.pulls.get({
+        owner: ctx.owner,
+        repo: ctx.name,
+        pull_number,
+      });
 
-    const data = pr.data;
+      const data = pr.data;
 
-    const baseBranch = data.base.ref;
-    const headBranch = data.head.ref;
+      // detect fork PRs - head repo differs from base repo
+      const isFork = data.head.repo.full_name !== data.base.repo.full_name;
 
-    if (!baseBranch) {
-      throw new Error(`Base branch not found for PR #${pull_number}`);
-    }
-
-    // detect fork PRs - head repo differs from base repo
-    const baseRepo = data.base.repo.full_name;
-    const headRepo = data.head.repo.full_name;
-    const isFork = headRepo !== baseRepo;
-
-    // use gh pr checkout which handles fork PRs automatically
-    // it adds the fork as a remote if needed and checks out the PR branch
-    log.info(`Checking out PR #${pull_number} using gh pr checkout`);
-    $("gh", ["pr", "checkout", pull_number.toString()]);
-
-    // fetch base branch for diff comparison
-    log.info(`Fetching base branch: origin/${baseBranch}`);
-    $("git", ["fetch", "origin", baseBranch, "--depth=20"]);
-
-    // get current git status for summary
-    const currentBranch = $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false }).trim();
-    const currentSha = $("git", ["rev-parse", "HEAD"], { log: false }).trim();
-    const baseSha = $("git", ["rev-parse", `origin/${baseBranch}`], { log: false }).trim();
-
-    // build summary
-    const summary = `PR branch has been fetched and checked out:
-- Base branch: \`origin/${baseBranch}\` (${baseSha.substring(0, 7)})
-- PR branch: \`${headBranch}\` (checked out locally, ${currentSha.substring(0, 7)})
-- Current branch: \`${currentBranch}\`
-- View diff: \`git diff origin/${baseBranch}...HEAD\``;
-
-    return {
-      number: data.number,
-      url: data.html_url,
-      title: data.title,
-      state: data.state,
-      draft: data.draft,
-      merged: data.merged,
-      base: baseBranch,
-      head: headBranch,
-      isFork,
-      summary,
-    };
-  }),
-});
+      return {
+        number: data.number,
+        url: data.html_url,
+        title: data.title,
+        state: data.state,
+        draft: data.draft,
+        merged: data.merged,
+        base: data.base.ref,
+        head: data.head.ref,
+        isFork,
+      };
+    }),
+  });
+}

mcp/review.ts

@@ -1,8 +1,9 @@
 import type { RestEndpointMethodTypes } from "@octokit/rest";
 import { type } from "arktype";
+import type { Context } from "../main.ts";
 import { buildPullfrogFooter } from "../utils/buildPullfrogFooter.ts";
 import { deleteProgressComment } from "./comment.ts";
-import { contextualize, tool } from "./shared.ts";
+import { execute, tool } from "./shared.ts";
 
 export const Review = type({
   pull_number: type.number.describe("The pull request number to review"),
@@ -39,81 +40,83 @@ export const Review = type({
     .optional(),
 });
 
-export const ReviewTool = tool({
-  name: "submit_pull_request_review",
-  description:
-    "Submit a review for an existing pull request. " +
-    "IMPORTANT: 95%+ of feedback should be in 'comments' array with file paths and line numbers. " +
-    "Only use 'body' for a 1-2 sentence summary with urgency and critical callouts.",
-  parameters: Review,
-  execute: contextualize(async ({ pull_number, body, commit_id, comments = [] }, ctx) => {
-    // get the PR to determine the head commit if commit_id not provided
-    const pr = await ctx.octokit.rest.pulls.get({
-      owner: ctx.owner,
-      repo: ctx.name,
-      pull_number,
-    });
-
-    // compose the request
-    const params: RestEndpointMethodTypes["pulls"]["createReview"]["parameters"] = {
-      owner: ctx.owner,
-      repo: ctx.name,
-      pull_number,
-      event: "COMMENT",
-    };
-    if (body) params.body = body;
-    if (commit_id) {
-      params.commit_id = commit_id;
-    } else {
-      params.commit_id = pr.data.head.sha;
-    }
-    if (comments.length > 0) {
-      type ReviewComment = (typeof params.comments & {})[number];
-      // convert comments to the format expected by GitHub API
-      params.comments = comments.map((comment) => {
-        const reviewComment: ReviewComment = {
-          ...comment,
-        };
-        reviewComment.side = comment.side || "RIGHT";
-        if (comment.start_line) {
-          reviewComment.start_line = comment.start_line;
-          reviewComment.start_side = comment.side || "RIGHT";
-        }
-        return reviewComment;
+export function ReviewTool(ctx: Context) {
+  return tool({
+    name: "submit_pull_request_review",
+    description:
+      "Submit a review for an existing pull request. " +
+      "IMPORTANT: 95%+ of feedback should be in 'comments' array with file paths and line numbers. " +
+      "Only use 'body' for a 1-2 sentence summary with urgency and critical callouts.",
+    parameters: Review,
+    execute: execute(ctx, async ({ pull_number, body, commit_id, comments = [] }) => {
+      // get the PR to determine the head commit if commit_id not provided
+      const pr = await ctx.octokit.rest.pulls.get({
+        owner: ctx.owner,
+        repo: ctx.name,
+        pull_number,
       });
-    }
-    const result = await ctx.octokit.rest.pulls.createReview(params);
-    const reviewId = result.data.id;
 
-    // build quick links footer and update the review body
-    const apiUrl = process.env.API_URL || "https://pullfrog.com";
-    const fixAllUrl = `${apiUrl}/trigger/${ctx.owner}/${ctx.name}/${pull_number}?action=fix&review_id=${reviewId}`;
-    const fixApprovedUrl = `${apiUrl}/trigger/${ctx.owner}/${ctx.name}/${pull_number}?action=fix-approved&review_id=${reviewId}`;
+      // compose the request
+      const params: RestEndpointMethodTypes["pulls"]["createReview"]["parameters"] = {
+        owner: ctx.owner,
+        repo: ctx.name,
+        pull_number,
+        event: "COMMENT",
+      };
+      if (body) params.body = body;
+      if (commit_id) {
+        params.commit_id = commit_id;
+      } else {
+        params.commit_id = pr.data.head.sha;
+      }
+      if (comments.length > 0) {
+        type ReviewComment = (typeof params.comments & {})[number];
+        // convert comments to the format expected by GitHub API
+        params.comments = comments.map((comment) => {
+          const reviewComment: ReviewComment = {
+            ...comment,
+          };
+          reviewComment.side = comment.side || "RIGHT";
+          if (comment.start_line) {
+            reviewComment.start_line = comment.start_line;
+            reviewComment.start_side = comment.side || "RIGHT";
+          }
+          return reviewComment;
+        });
+      }
+      const result = await ctx.octokit.rest.pulls.createReview(params);
+      const reviewId = result.data.id;
 
-    const footer = buildPullfrogFooter({
-      customParts: [`[Fix all ➔](${fixAllUrl})`, `[Fix 👍s ➔](${fixApprovedUrl})`],
-    });
+      // build quick links footer and update the review body
+      const apiUrl = process.env.API_URL || "https://pullfrog.com";
+      const fixAllUrl = `${apiUrl}/trigger/${ctx.owner}/${ctx.name}/${pull_number}?action=fix&review_id=${reviewId}`;
+      const fixApprovedUrl = `${apiUrl}/trigger/${ctx.owner}/${ctx.name}/${pull_number}?action=fix-approved&review_id=${reviewId}`;
 
-    const updatedBody = (body || "") + footer;
+      const footer = buildPullfrogFooter({
+        customParts: [`[Fix all ➔](${fixAllUrl})`, `[Fix 👍s ➔](${fixApprovedUrl})`],
+      });
 
-    // update the review with the footer
-    await ctx.octokit.rest.pulls.updateReview({
-      owner: ctx.owner,
-      repo: ctx.name,
-      pull_number,
-      review_id: reviewId,
-      body: updatedBody,
-    });
+      const updatedBody = (body || "") + footer;
 
-    await deleteProgressComment();
+      // update the review with the footer
+      await ctx.octokit.rest.pulls.updateReview({
+        owner: ctx.owner,
+        repo: ctx.name,
+        pull_number,
+        review_id: reviewId,
+        body: updatedBody,
+      });
 
-    return {
-      success: true,
-      reviewId,
-      html_url: result.data.html_url,
-      state: result.data.state,
-      user: result.data.user?.login,
-      submitted_at: result.data.submitted_at,
-    };
-  }),
-});
+      await deleteProgressComment(ctx);
+
+      return {
+        success: true,
+        reviewId,
+        html_url: result.data.html_url,
+        state: result.data.state,
+        user: result.data.user?.login,
+        submitted_at: result.data.submitted_at,
+      };
+    }),
+  });
+}

mcp/reviewComments.ts

@@ -1,76 +1,220 @@
 import { type } from "arktype";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
+
+// graphql query to fetch all review threads with comments and replies
+// note: diffSide and startDiffSide are on the thread, not the comment
+const REVIEW_THREADS_QUERY = `
+query ($owner: String!, $repo: String!, $pullNumber: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pullNumber) {
+      reviewThreads(first: 100) {
+        nodes {
+          diffSide
+          startDiffSide
+          comments(first: 100) {
+            nodes {
+              id
+              databaseId
+              body
+              path
+              line
+              startLine
+              url
+              author {
+                login
+              }
+              createdAt
+              updatedAt
+              pullRequestReview {
+                databaseId
+              }
+              replyTo {
+                databaseId
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`;
+
+// graphql response types (nodes arrays can contain nulls per GitHub GraphQL spec)
+type GraphQLReviewComment = {
+  id: string;
+  databaseId: number;
+  body: string;
+  path: string;
+  line: number | null;
+  startLine: number | null;
+  url: string;
+  author: {
+    login: string;
+  } | null;
+  createdAt: string;
+  updatedAt: string;
+  pullRequestReview: {
+    databaseId: number;
+  } | null;
+  replyTo: {
+    databaseId: number;
+  } | null;
+};
+
+type GraphQLReviewThread = {
+  diffSide: "LEFT" | "RIGHT";
+  startDiffSide: "LEFT" | "RIGHT" | null;
+  comments: {
+    nodes: (GraphQLReviewComment | null)[] | null;
+  } | null;
+} | null;
+
+type GraphQLResponse = {
+  repository: {
+    pullRequest: {
+      reviewThreads: {
+        nodes: (GraphQLReviewThread | null)[] | null;
+      } | null;
+    } | null;
+  } | null;
+};
 
 export const GetReviewComments = type({
   pull_number: type.number.describe("The pull request number"),
   review_id: type.number.describe("The review ID to get comments for"),
 });
 
-export const GetReviewCommentsTool = tool({
-  name: "get_review_comments",
-  description:
-    "Get all review comments for a specific pull request review. Returns line-by-line comments that were left on specific code locations.",
-  parameters: GetReviewComments,
-  execute: contextualize(async ({ pull_number, review_id }, ctx) => {
-    const comments = await ctx.octokit.paginate(ctx.octokit.rest.pulls.listCommentsForReview, {
-      owner: ctx.owner,
-      repo: ctx.name,
-      pull_number,
-      review_id,
-    });
+export function GetReviewCommentsTool(ctx: Context) {
+  return tool({
+    name: "get_review_comments",
+    description:
+      "Get all review comments and their replies for a specific pull request review. Returns line-by-line comments that were left on specific code locations, including any threaded replies.",
+    parameters: GetReviewComments,
+    execute: execute(ctx, async ({ pull_number, review_id }) => {
+      // fetch all review threads using graphql
+      const response = await ctx.octokit.graphql<GraphQLResponse>(REVIEW_THREADS_QUERY, {
+        owner: ctx.owner,
+        repo: ctx.name,
+        pullNumber: pull_number,
+      });
 
-    return {
-      review_id,
-      pull_number,
-      comments: comments.map((comment) => ({
-        id: comment.id,
-        body: comment.body,
-        path: comment.path,
-        line: comment.line,
-        side: comment.side,
-        start_line: comment.start_line,
-        start_side: comment.start_side,
-        user: typeof comment.user === "string" ? comment.user : comment.user?.login,
-        created_at: comment.created_at,
-        updated_at: comment.updated_at,
-        html_url: comment.html_url,
-        in_reply_to_id: comment.in_reply_to_id,
-        diff_hunk: comment.diff_hunk,
-        reactions: comment.reactions,
-      })),
-      count: comments.length,
-    };
-  }),
-});
+      const pullRequest = response.repository?.pullRequest;
+      if (!pullRequest) {
+        return {
+          review_id,
+          pull_number,
+          comments: [],
+          count: 0,
+        };
+      }
+
+      const threadNodes = pullRequest.reviewThreads?.nodes;
+      if (!threadNodes) {
+        return {
+          review_id,
+          pull_number,
+          comments: [],
+          count: 0,
+        };
+      }
+
+      const allComments: {
+        id: number;
+        body: string;
+        path: string;
+        line: number | null;
+        side: "LEFT" | "RIGHT";
+        start_line: number | null;
+        start_side: "LEFT" | "RIGHT" | null;
+        user: string | null;
+        created_at: string;
+        updated_at: string;
+        html_url: string;
+        in_reply_to_id: number | null;
+        pull_request_review_id: number | null;
+      }[] = [];
+
+      // iterate through all threads (filter out nulls)
+      for (const thread of threadNodes) {
+        if (!thread?.comments?.nodes) continue;
+
+        // filter out null comments
+        const threadComments = thread.comments.nodes.filter(
+          (c): c is GraphQLReviewComment => c !== null
+        );
+        if (threadComments.length === 0) continue;
+
+        // find the root comment (the one with replyTo == null) to determine thread ownership
+        const rootComment = threadComments.find((c) => c.replyTo === null);
+        if (!rootComment) continue;
+
+        // check if this thread belongs to the target review using the root comment
+        const threadBelongsToReview = rootComment.pullRequestReview?.databaseId === review_id;
+        if (!threadBelongsToReview) continue;
+
+        // include all comments from this thread (original + replies)
+        // side info comes from thread level, not comment level
+        for (const comment of threadComments) {
+          allComments.push({
+            id: comment.databaseId,
+            body: comment.body,
+            path: comment.path,
+            line: comment.line,
+            start_line: comment.startLine,
+            side: thread.diffSide,
+            start_side: thread.startDiffSide,
+            user: comment.author?.login ?? null,
+            created_at: comment.createdAt,
+            updated_at: comment.updatedAt,
+            html_url: comment.url,
+            in_reply_to_id: comment.replyTo?.databaseId ?? null,
+            pull_request_review_id: comment.pullRequestReview?.databaseId ?? null,
+          });
+        }
+      }
+
+      return {
+        review_id,
+        pull_number,
+        comments: allComments,
+        count: allComments.length,
+      };
+    }),
+  });
+}
 
 export const ListPullRequestReviews = type({
   pull_number: type.number.describe("The pull request number to list reviews for"),
 });
 
-export const ListPullRequestReviewsTool = tool({
-  name: "list_pull_request_reviews",
-  description:
-    "List all reviews for a pull request. Returns all reviews including approvals, request changes, and comments.",
-  parameters: ListPullRequestReviews,
-  execute: contextualize(async ({ pull_number }, ctx) => {
-    const reviews = await ctx.octokit.paginate(ctx.octokit.rest.pulls.listReviews, {
-      owner: ctx.owner,
-      repo: ctx.name,
-      pull_number,
-    });
+export function ListPullRequestReviewsTool(ctx: Context) {
+  return tool({
+    name: "list_pull_request_reviews",
+    description:
+      "List all reviews for a pull request. Returns all reviews including approvals, request changes, and comments.",
+    parameters: ListPullRequestReviews,
+    execute: execute(ctx, async ({ pull_number }) => {
+      const reviews = await ctx.octokit.paginate(ctx.octokit.rest.pulls.listReviews, {
+        owner: ctx.owner,
+        repo: ctx.name,
+        pull_number,
+      });
 
-    return {
-      pull_number,
-      reviews: reviews.map((review) => ({
-        id: review.id,
-        body: review.body,
-        state: review.state,
-        user: review.user?.login,
-        commit_id: review.commit_id,
-        submitted_at: review.submitted_at,
-        html_url: review.html_url,
-      })),
-      count: reviews.length,
-    };
-  }),
-});
+      return {
+        pull_number,
+        reviews: reviews.map((review) => ({
+          id: review.id,
+          body: review.body,
+          state: review.state,
+          user: review.user?.login,
+          commit_id: review.commit_id,
+          submitted_at: review.submitted_at,
+          html_url: review.html_url,
+        })),
+        count: reviews.length,
+      };
+    }),
+  });
+}

mcp/selectMode.ts

@@ -1,5 +1,6 @@
 import { type } from "arktype";
-import { contextualize, tool } from "./shared.ts";
+import type { Context } from "../main.ts";
+import { execute, tool } from "./shared.ts";
 
 export const SelectMode = type({
   modeName: type.string.describe(
@@ -7,26 +8,28 @@ export const SelectMode = type({
   ),
 });
 
-export const SelectModeTool = tool({
-  name: "select_mode",
-  description:
-    "Select a mode and get its detailed prompt instructions. Call this first to determine which mode to use based on the request.",
-  parameters: SelectMode,
-  execute: contextualize(async ({ modeName }, ctx) => {
-    const selectedMode = ctx.modes.find((m) => m.name.toLowerCase() === modeName.toLowerCase());
+export function SelectModeTool(ctx: Context) {
+  return tool({
+    name: "select_mode",
+    description:
+      "Select a mode and get its detailed prompt instructions. Call this first to determine which mode to use based on the request.",
+    parameters: SelectMode,
+    execute: execute(ctx, async ({ modeName }) => {
+      const selectedMode = ctx.modes.find((m) => m.name.toLowerCase() === modeName.toLowerCase());
+
+      if (!selectedMode) {
+        const availableModes = ctx.modes.map((m) => m.name).join(", ");
+        return {
+          error: `Mode "${modeName}" not found. Available modes: ${availableModes}`,
+          availableModes: ctx.modes.map((m) => ({ name: m.name, description: m.description })),
+        };
+      }
 
-    if (!selectedMode) {
-      const availableModes = ctx.modes.map((m) => m.name).join(", ");
       return {
-        error: `Mode "${modeName}" not found. Available modes: ${availableModes}`,
-        availableModes: ctx.modes.map((m) => ({ name: m.name, description: m.description })),
+        modeName: selectedMode.name,
+        description: selectedMode.description,
+        prompt: selectedMode.prompt,
       };
-    }
-
-    return {
-      modeName: selectedMode.name,
-      description: selectedMode.description,
-      prompt: selectedMode.prompt,
-    };
-  }),
-});
+    }),
+  });
+}

mcp/server.ts

@@ -3,6 +3,7 @@ import "./arkConfig.ts";
 import { createServer } from "node:net";
 import { FastMCP, type Tool } from "fastmcp";
 import { ghPullfrogMcpName } from "../external.ts";
+import type { Context } from "../main.ts";
 import { GetCheckSuiteLogsTool } from "./checkSuite.ts";
 import {
   CreateCommentTool,
@@ -22,12 +23,7 @@ import { PullRequestInfoTool } from "./prInfo.ts";
 import { ReviewTool } from "./review.ts";
 import { GetReviewCommentsTool, ListPullRequestReviewsTool } from "./reviewComments.ts";
 import { SelectModeTool } from "./selectMode.ts";
-import {
-  addTools,
-  initMcpContext,
-  isProgressCommentDisabled,
-  type McpInitContext,
-} from "./shared.ts";
+import { addTools, isProgressCommentDisabled } from "./shared.ts";
 
 /**
  * Find an available port starting from the given port
@@ -62,43 +58,42 @@ async function findAvailablePort(startPort: number): Promise<number> {
  * Start the MCP HTTP server and return the URL and close function
  */
 export async function startMcpHttpServer(
-  state: McpInitContext
+  ctx: Context
 ): Promise<{ url: string; close: () => Promise<void> }> {
-  initMcpContext(state);
-
   const server = new FastMCP({
     name: ghPullfrogMcpName,
     version: "0.0.1",
   });
 
+  // create all tools as factories, passing ctx
   const tools: Tool<any, any>[] = [
-    SelectModeTool,
-    CreateCommentTool,
-    EditCommentTool,
-    ReplyToReviewCommentTool,
-    IssueTool,
-    IssueInfoTool,
-    GetIssueCommentsTool,
-    GetIssueEventsTool,
-    PullRequestTool,
-    ReviewTool,
-    PullRequestInfoTool,
-    GetReviewCommentsTool,
-    ListPullRequestReviewsTool,
-    GetCheckSuiteLogsTool,
+    SelectModeTool(ctx),
+    CreateCommentTool(ctx),
+    EditCommentTool(ctx),
+    ReplyToReviewCommentTool(ctx),
+    IssueTool(ctx),
+    IssueInfoTool(ctx),
+    GetIssueCommentsTool(ctx),
+    GetIssueEventsTool(ctx),
+    PullRequestTool(ctx),
+    ReviewTool(ctx),
+    PullRequestInfoTool(ctx),
+    GetReviewCommentsTool(ctx),
+    ListPullRequestReviewsTool(ctx),
+    GetCheckSuiteLogsTool(ctx),
     DebugShellCommandTool,
-    AddLabelsTool,
-    CreateBranchTool,
-    CommitFilesTool,
-    PushBranchTool,
+    AddLabelsTool(ctx),
+    CreateBranchTool(ctx),
+    CommitFilesTool(ctx),
+    PushBranchTool(ctx),
   ];
 
   // only include ReportProgressTool if progress comment is not disabled
-  if (!isProgressCommentDisabled()) {
-    tools.push(ReportProgressTool);
+  if (!isProgressCommentDisabled(ctx)) {
+    tools.push(ReportProgressTool(ctx));
   }
 
-  addTools(server, tools);
+  addTools(ctx, server, tools);
 
   const port = await findAvailablePort(3764);
   const host = "127.0.0.1";

mcp/shared.ts

@@ -1,46 +1,60 @@
-import { Octokit } from "@octokit/rest";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { FastMCP, Tool } from "fastmcp";
-import type { Payload } from "../external.ts";
-import type { Mode } from "../modes.ts";
-import { getGitHubInstallationToken, parseRepoContext, type RepoContext } from "../utils/github.ts";
-
-export interface McpInitContext {
-  payload: Payload;
-  modes: Mode[];
-  agentName?: string;
-}
-
-let mcpInitContext: McpInitContext | undefined;
-
-// this must be called on mcp server initialization
-export function initMcpContext(state: McpInitContext): void {
-  mcpInitContext = state;
-}
-
-export interface McpContext extends McpInitContext, RepoContext {
-  octokit: Octokit;
-}
-
-export function getMcpContext(): McpContext {
-  if (!mcpInitContext) {
-    throw new Error("MCP context not initialized. Call initializeMcpContext first.");
-  }
-  return {
-    ...mcpInitContext,
-    ...parseRepoContext(),
-    octokit: new Octokit({
-      auth: getGitHubInstallationToken(),
-    }),
-  };
-}
-
-export function isProgressCommentDisabled(): boolean {
-  return mcpInitContext?.payload.disableProgressComment === true;
-}
+import type { Context } from "../main.ts";
 
 export const tool = <const params>(toolDef: Tool<any, StandardSchemaV1<params>>) => toolDef;
 
+export interface ToolResult {
+  content: {
+    type: "text";
+    text: string;
+  }[];
+  isError?: boolean;
+}
+
+export const handleToolSuccess = (data: Record<string, any>): ToolResult => {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2),
+      },
+    ],
+  };
+};
+
+export const handleToolError = (error: unknown): ToolResult => {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: ${errorMessage}`,
+      },
+    ],
+    isError: true,
+  };
+};
+
+/**
+ * Helper to wrap a tool execute function with error handling.
+ * Captures ctx in closure so tools don't need to handle try/catch.
+ */
+export const execute = <T>(ctx: Context, fn: (params: T) => Promise<Record<string, any>>) => {
+  return async (params: T): Promise<ToolResult> => {
+    try {
+      const result = await fn(params);
+      return handleToolSuccess(result);
+    } catch (error) {
+      return handleToolError(error);
+    }
+  };
+};
+
+export function isProgressCommentDisabled(ctx: Context): boolean {
+  return ctx.payload.disableProgressComment === true;
+}
+
 /**
  * Sanitize JSON schema to remove problematic fields that Gemini CLI/API can't handle
  * - Removes $schema field (causes "no schema with key or ref" errors)
@@ -162,11 +176,10 @@ function sanitizeTool<T extends Tool<any, any>>(tool: T): T {
   } as T;
 }
 
-export const addTools = (server: FastMCP, tools: Tool<any, any>[]) => {
+export const addTools = (ctx: Context, server: FastMCP, tools: Tool<any, any>[]) => {
   // sanitize schemas for gemini agent and opencode (when using Google API)
   // both have issues with draft-2020-12 schemas and any_of enum constructs
-  const shouldSanitize =
-    mcpInitContext?.agentName === "gemini" || mcpInitContext?.agentName === "opencode";
+  const shouldSanitize = ctx.agentName === "gemini" || ctx.agentName === "opencode";
 
   for (const tool of tools) {
     const processedTool = shouldSanitize ? sanitizeTool(tool) : tool;
@@ -174,49 +187,3 @@ export const addTools = (server: FastMCP, tools: Tool<any, any>[]) => {
   }
   return server;
 };
-
-export const contextualize = <T>(
-  executor: (params: T, ctx: McpContext) => Promise<Record<string, any>>
-) => {
-  return async (params: T): Promise<ToolResult> => {
-    try {
-      const ctx = getMcpContext();
-      const result = await executor(params, ctx);
-      return handleToolSuccess(result);
-    } catch (error) {
-      return handleToolError(error);
-    }
-  };
-};
-
-export interface ToolResult {
-  content: {
-    type: "text";
-    text: string;
-  }[];
-  isError?: boolean;
-}
-
-const handleToolSuccess = (data: Record<string, any>): ToolResult => {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(data, null, 2),
-      },
-    ],
-  };
-};
-
-const handleToolError = (error: unknown): ToolResult => {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Error: ${errorMessage}`,
-      },
-    ],
-    isError: true,
-  };
-};

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pullfrog/action",
-  "version": "0.0.137",
+  "version": "0.0.144",
   "type": "module",
   "files": [
     "index.js",

utils/buildPullfrogFooter.ts

@@ -40,8 +40,9 @@ export function buildPullfrogFooter(params: BuildPullfrogFooterParams): string {
   }
 
   if (params.workflowRun) {
-    const { owner, repo, runId } = params.workflowRun;
-    parts.push(`[View workflow run](https://github.com/${owner}/${repo}/actions/runs/${runId})`);
+    parts.push(
+      `[View workflow run](https://github.com/${params.workflowRun.owner}/${params.workflowRun.repo}/actions/runs/${params.workflowRun.runId})`
+    );
   }
 
   if (params.customParts) {

utils/errorReport.ts

@@ -48,16 +48,9 @@ export async function reportErrorToComment({
     }
   }
 
-  // if no comment ID available, try using reportProgress (requires MCP context)
+  // if no comment ID available, can't update comment
   if (!commentId) {
-    try {
-      const { reportProgress } = await import("../mcp/comment.ts");
-      await reportProgress({ body: formattedError });
-      return;
-    } catch {
-      // MCP context not available, can't create/update comment
-      return;
-    }
+    return;
   }
 
   // update comment directly using GitHub API

utils/setup.ts

@@ -1,8 +1,7 @@
 import { execSync } from "node:child_process";
 import { existsSync, rmSync } from "node:fs";
-import type { Payload } from "../external.ts";
+import type { Context } from "../main.ts";
 import { log } from "./cli.ts";
-import type { RepoContext } from "./github.ts";
 import { $ } from "./shell.ts";
 
 export interface SetupOptions {
@@ -63,20 +62,21 @@ export function setupGitConfig(): void {
   }
 }
 
+export type SetupGitResult = {
+  pushRemote: string;
+};
+
 /**
- * Setup git authentication using GitHub installation token
- * Always uses the installation token, scoped to the current repo only
+ * Unified git setup: configures authentication and checks out PR branch if applicable.
+ * For PR events, always returns a push URL constructed from the PR's head repo.
+ * This works for both same-repo and fork PRs with a single code path.
  */
-export function setupGitAuth(ctx: {
-  githubInstallationToken: string;
-  repoContext: RepoContext;
-}): void {
+export async function setupGit(ctx: Context): Promise<SetupGitResult> {
   const repoDir = process.cwd();
 
-  log.info("🔐 Setting up git authentication...");
+  log.info("🔧 Setting up git authentication...");
 
-  // Remove existing git auth headers that actions/checkout might have set
-  // Use --local to scope to this repo only
+  // remove existing git auth headers that actions/checkout might have set
   try {
     execSync("git config --local --unset-all http.https://github.com/.extraheader", {
       cwd: repoDir,
@@ -87,70 +87,40 @@ export function setupGitAuth(ctx: {
     log.debug("No existing authentication headers to remove");
   }
 
-  // Update remote URL to embed the token
-  // This is scoped to the repo's .git/config, not the user's global config
-  const remoteUrl = `https://x-access-token:${ctx.githubInstallationToken}@github.com/${ctx.repoContext.owner}/${ctx.repoContext.name}.git`;
-  $("git", ["remote", "set-url", "origin", remoteUrl], { cwd: repoDir });
-  log.info("✓ Updated remote URL with authentication token (scoped to repo)");
-}
-
-/**
- * Setup git branch based on payload event context
- * Automatically checks out the appropriate branch before agent execution
- */
-export function setupGitBranch(payload: Payload): void {
-  const branch = payload.event.branch;
-  const repoDir = process.cwd();
-
-  if (!branch) {
-    log.debug("No branch specified in payload, using default branch");
-    return;
-  }
-
-  log.info(`🌿 Setting up git branch: ${branch}`);
-
-  // if this is a PR-related event, use gh pr checkout which handles fork PRs automatically
-  if (payload.event.is_pr === true && payload.event.issue_number) {
-    const prNumber = payload.event.issue_number;
-    try {
-      // gh pr checkout handles fork PRs by setting up remotes automatically
-      log.debug(`Checking out PR #${prNumber} using gh pr checkout`);
-      execSync(`gh pr checkout ${prNumber}`, {
-        cwd: repoDir,
-        stdio: "pipe",
-      });
-
-      log.info(`✓ Successfully checked out PR branch: ${branch}`);
-      return;
-    } catch (error) {
-      // if gh pr checkout fails, fall back to branch name fetch
-      log.debug(
-        `gh pr checkout failed, falling back to branch name fetch: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  // fallback: fetch by branch name (for non-PR contexts or if PR ref fetch failed)
-  try {
-    log.debug(`Fetching branch from origin: ${branch}`);
-    execSync(`git fetch origin ${branch}`, {
-      cwd: repoDir,
-      stdio: "pipe",
-    });
-
-    // checkout the branch, creating local tracking branch
-    log.debug(`Checking out branch: ${branch}`);
-    execSync(`git checkout -B ${branch} origin/${branch}`, {
-      cwd: repoDir,
-      stdio: "pipe",
-    });
-
-    log.info(`✓ Successfully checked out branch: ${branch}`);
-  } catch (error) {
-    // if git operations fail, log warning but don't fail the action
-    // the agent might still be able to work with the default branch
-    log.warning(
-      `Failed to checkout branch ${branch}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
+  // non-PR events: set up origin with token, stay on default branch
+  if (ctx.payload.event.is_pr !== true || !ctx.payload.event.issue_number) {
+    const originUrl = `https://x-access-token:${ctx.githubInstallationToken}@github.com/${ctx.owner}/${ctx.name}.git`;
+    $("git", ["remote", "set-url", "origin", originUrl], { cwd: repoDir });
+    log.info("✓ Updated origin URL with authentication token");
+    return { pushRemote: "origin" };
+  }
+
+  // PR event: fetch PR info to get branch name and head repo
+  const prNumber = ctx.payload.event.issue_number;
+  const pr = await ctx.octokit.rest.pulls.get({
+    owner: ctx.owner,
+    repo: ctx.name,
+    pull_number: prNumber,
+  });
+
+  const headRepo = pr.data.head.repo;
+  if (!headRepo) {
+    throw new Error(`PR #${prNumber} source repository was deleted`);
+  }
+
+  // checkout PR branch using plain git (no gh cli needed)
+  const branch = pr.data.head.ref;
+  log.info(`🌿 Checking out PR #${prNumber} (${branch})...`);
+  $("git", ["fetch", "origin", `pull/${prNumber}/head:${branch}`], { cwd: repoDir });
+  $("git", ["checkout", branch], { cwd: repoDir });
+  log.info(`✓ Successfully checked out PR #${prNumber}`);
+
+  // unified push URL - works for both same-repo and fork PRs
+  const token = process.env.GITHUB_TOKEN || ctx.githubInstallationToken;
+  const pushUrl = `https://x-access-token:${token}@github.com/${headRepo.full_name}.git`;
+  const isFork = headRepo.full_name !== pr.data.base.repo.full_name;
+  if (isFork) {
+    log.info(`🍴 Fork PR detected, will push to: ${headRepo.full_name}`);
+  }
+  return { pushRemote: pushUrl };
 }

utils/shell.ts

@@ -14,6 +14,7 @@ interface ShellOptions {
     | "ucs2"
     | "utf16le";
   log?: boolean;
+  env?: Record<string, string>;
   onError?: (result: { status: number; stdout: string; stderr: string }) => void;
 }
 
@@ -36,6 +37,7 @@ export function $(cmd: string, args: string[], options?: ShellOptions): string {
     stdio: ["ignore", "pipe", "pipe"],
     encoding,
     cwd: options?.cwd,
+    env: options?.env ? { ...process.env, ...options.env } : undefined,
   });
 
   const stdout = result.stdout ?? "";