110

agents/index.ts

@@ -1,13 +1,15 @@
+import type { AgentName } from "../external.ts";
 import { claude } from "./claude.ts";
 import { codex } from "./codex.ts";
 import { cursor } from "./cursor.ts";
 import { gemini } from "./gemini.ts";
+import type { Agent } from "./shared.ts";
 
 export const agents = {
   claude,
   codex,
   cursor,
   gemini,
-} as const;
+} satisfies Record<AgentName, Agent>;
 
 export type AgentInputKey = (typeof agents)[keyof typeof agents]["inputKeys"][number];

agents/instructions.ts

@@ -1,5 +1,5 @@
 import type { Payload } from "../external.ts";
-import { ghPullfrogMcpName } from "../mcp/index.ts";
+import { ghPullfrogMcpName } from "../external.ts";
 import { modes } from "../modes.ts";
 
 export const addInstructions = (payload: Payload) =>
@@ -46,13 +46,17 @@ Ensure after your edits are done, your final comments do not contain intermediat
 
 ## Mode Selection
 
-choose the appropriate mode based on the prompt payload:
+Before starting any work, you must first determine which mode to use by examining the request and calling ${ghPullfrogMcpName}/select_mode.
+
+Available modes:
 
 ${[...modes, ...payload.modes].map((w) => `    - "${w.name}": ${w.description}`).join("\n")}
 
-## Modes
-
-${[...modes, ...payload.modes].map((w) => `### ${w.name}\n\n${w.prompt}`).join("\n\n")}
+**IMPORTANT**: The first thing you must do is:
+1. Examine the user's request/prompt carefully
+2. Determine which mode is most appropriate based on the mode descriptions above
+3. Call ${ghPullfrogMcpName}/select_mode with the chosen mode name
+4. The tool will return detailed instructions for that mode - follow those instructions exactly
 
 ************* USER PROMPT *************
 

agents/shared.ts

@@ -1,7 +1,5 @@
 import { spawnSync } from "node:child_process";
 import { chmodSync, createWriteStream, existsSync } from "node:fs";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { pipeline } from "node:stream/promises";
 import type { McpStdioServerConfig } from "@anthropic-ai/claude-agent-sdk";
@@ -97,11 +95,7 @@ export async function installFromNpmTarball({
 
   log.info(`📦 Installing ${packageName}@${resolvedVersion}...`);
 
-  // Derive temp directory prefix from package name (remove @, replace / with -, add trailing -)
-  const tempDirPrefix = packageName.replace("@", "").replace(/\//g, "-") + "-";
-
-  // Create temp directory
-  const tempDir = await mkdtemp(join(tmpdir(), tempDirPrefix));
+  const tempDir = process.env.PULLFROG_TEMP_DIR!;
   const tarballPath = join(tempDir, "package.tgz");
 
   // Download tarball from npm
@@ -183,12 +177,7 @@ export async function installFromCurl({
 }: InstallFromCurlParams): Promise<string> {
   log.info(`📦 Installing ${executableName}...`);
 
-  // Derive temp directory prefix from executable name (sanitize similar to package name)
-  // Replace any special characters with - and ensure trailing -
-  const tempDirPrefix = executableName.replace(/[^a-zA-Z0-9]/g, "-") + "-";
-
-  // Create temp directory
-  const tempDir = await mkdtemp(join(tmpdir(), tempDirPrefix));
+  const tempDir = process.env.PULLFROG_TEMP_DIR!;
   const installScriptPath = join(tempDir, "install.sh");
 
   // Download the install script
@@ -206,7 +195,7 @@ export async function installFromCurl({
   // Make install script executable
   chmodSync(installScriptPath, 0o755);
 
-  log.info("Installing to temp directory...");
+  log.info(`Installing to temp directory at ${tempDir}...`);
 
   // Run the install script with HOME set to temp directory
   // The Cursor install script installs to $HOME/.local/bin/{executableName}

external.ts

@@ -1,6 +1,38 @@
-import type { AgentName } from "./main.ts";
+/**
+ * ⚠️ NO IMPORTS except modes.ts - this file is imported by Next.js and must avoid pulling in backend code.
+ * All shared constants, types, and data used by both the Next.js app and the action runtime live here.
+ * Other files in action/ re-export from this file for backward compatibility.
+ */
+
 import type { Mode } from "./modes.ts";
 
+// mcp name constant
+export const ghPullfrogMcpName = "gh-pullfrog";
+
+// agent manifest - static metadata about available agents
+export const agentsManifest = {
+  claude: {
+    name: "claude",
+    apiKeys: ["anthropic_api_key"],
+  },
+  codex: {
+    name: "codex",
+    apiKeys: ["openai_api_key"],
+  },
+  cursor: {
+    name: "cursor",
+    apiKeys: ["cursor_api_key"],
+  },
+  gemini: {
+    name: "gemini",
+    apiKeys: ["google_api_key", "gemini_api_key"],
+  },
+} as const;
+
+// agent name type - union of agent slugs
+export type AgentName = keyof typeof agentsManifest;
+
+// payload type for agent execution
 export type Payload = {
   "~pullfrog": true;
 

main.ts

@@ -1,7 +1,11 @@
+import { existsSync, readFileSync } from "node:fs";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { flatMorph } from "@ark/util";
 import { type } from "arktype";
 import { agents } from "./agents/index.ts";
-import type { Payload } from "./external.ts";
+import type { AgentName as AgentNameType, Payload } from "./external.ts";
 import { createMcpConfigs } from "./mcp/config.ts";
 import { modes } from "./modes.ts";
 import packageJson from "./package.json" with { type: "json" };
@@ -15,8 +19,9 @@ import {
 } from "./utils/github.ts";
 import { setupGitAuth, setupGitConfig } from "./utils/setup.ts";
 
+// runtime validation using agents (needed for ArkType)
+// Note: The AgentName type is defined in external.ts, this is the runtime validator
 export const AgentName = type.enumerated(...Object.values(agents).map((agent) => agent.name));
-export type AgentName = typeof AgentName.infer;
 
 export const AgentInputKey = type.enumerated(
   ...Object.values(agents).flatMap((agent) => agent.inputKeys)
@@ -30,7 +35,7 @@ const keyInputDefs = flatMorph(agents, (_, agent) =>
 export const Inputs = type({
   prompt: "string",
   ...keyInputDefs,
-  "agent?": AgentName.or("undefined"),
+  "agent?": type.enumerated(...Object.values(agents).map((agent) => agent.name)).or("undefined"),
 });
 
 export type Inputs = typeof Inputs.infer;
@@ -41,6 +46,36 @@ export interface MainResult {
   error?: string | undefined;
 }
 
+export async function main(inputs: Inputs): Promise<MainResult> {
+  const partialCtx = await initializeContext(inputs);
+  const ctx = partialCtx as MainContext;
+
+  try {
+    await determineAgent(ctx);
+    setupGitAuth(ctx.githubInstallationToken, ctx.repoContext);
+    await setupTempDirectory(ctx);
+    setupMcpLogPolling(ctx);
+
+    ctx.payload = parsePayload(inputs);
+    setupMcpServers(ctx);
+    await installAgentCli(ctx);
+    validateApiKey(ctx);
+
+    const result = await runAgent(ctx);
+    return await handleAgentResult(result);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    log.error(errorMessage);
+    await log.writeSummary();
+    return {
+      success: false,
+      error: errorMessage,
+    };
+  } finally {
+    await cleanup(partialCtx);
+  }
+}
+
 /**
  * Throw an error for missing API key with helpful message linking to repo settings
  */
@@ -90,110 +125,165 @@ To fix this, add the required secret to your GitHub repository:
   throw new Error(message);
 }
 
-export async function main(inputs: Inputs): Promise<MainResult> {
-  let tokenToRevoke: string | null = null;
+interface MainContext {
+  inputs: Inputs;
+  githubInstallationToken: string;
+  tokenToRevoke: string | null;
+  repoContext: RepoContext;
+  agentName: AgentNameType;
+  agent: (typeof agents)[AgentNameType];
+  sharedTempDir: string;
+  mcpLogPath: string;
+  pollInterval: NodeJS.Timeout | null;
+  payload: Payload;
+  mcpServers: ReturnType<typeof createMcpConfigs>;
+  cliPath: string;
+  apiKey: string;
+}
 
-  try {
-    log.info(`🐸 Running pullfrog/action@${packageJson.version}...`);
+async function initializeContext(
+  inputs: Inputs
+): Promise<Omit<MainContext, "payload" | "mcpServers" | "cliPath" | "apiKey">> {
+  log.info(`🐸 Running pullfrog/action@${packageJson.version}...`);
+  Inputs.assert(inputs);
+  setupGitConfig();
 
-    Inputs.assert(inputs);
-    setupGitConfig();
+  const { githubInstallationToken, wasAcquired } = await setupGitHubInstallationToken();
+  const tokenToRevoke = wasAcquired ? githubInstallationToken : null;
+  const repoContext = parseRepoContext();
 
-    const { githubInstallationToken, wasAcquired } = await setupGitHubInstallationToken();
-    if (wasAcquired) {
-      tokenToRevoke = githubInstallationToken;
-    }
-    const repoContext = parseRepoContext();
+  return {
+    inputs,
+    githubInstallationToken,
+    tokenToRevoke,
+    repoContext,
+    agentName: "claude" as AgentNameType,
+    agent: agents.claude,
+    sharedTempDir: "",
+    mcpLogPath: "",
+    pollInterval: null,
+  };
+}
 
-    const repoSettings = await fetchRepoSettings({
-      token: githubInstallationToken,
-      repoContext,
-    });
+async function determineAgent(
+  ctx: Omit<MainContext, "payload" | "mcpServers" | "cliPath" | "apiKey">
+): Promise<void> {
+  const repoSettings = await fetchRepoSettings({
+    token: ctx.githubInstallationToken,
+    repoContext: ctx.repoContext,
+  });
 
-    const agentName: AgentName = inputs.agent || repoSettings.defaultAgent || "claude";
+  ctx.agentName = ctx.inputs.agent || repoSettings.defaultAgent || "claude";
+  ctx.agent = agents[ctx.agentName];
+}
 
-    const agent = agents[agentName];
+async function setupTempDirectory(
+  ctx: Omit<MainContext, "payload" | "mcpServers" | "cliPath" | "apiKey">
+): Promise<void> {
+  ctx.sharedTempDir = await mkdtemp(join(tmpdir(), "pullfrog-"));
+  process.env.PULLFROG_TEMP_DIR = ctx.sharedTempDir;
+  ctx.mcpLogPath = join(ctx.sharedTempDir, "mcpLog.txt");
+  await writeFile(ctx.mcpLogPath, "", "utf-8");
+  log.info(`📂 PULLFROG_TEMP_DIR has been created at ${ctx.sharedTempDir}`);
+}
 
-    setupGitAuth(githubInstallationToken, repoContext);
-
-    const mcpServers = createMcpConfigs(githubInstallationToken);
-
-    log.debug(`📋 MCP Config: ${JSON.stringify(mcpServers, null, 2)}`);
-
-    // Install agent CLI before running
-    const cliPath = await agent.install();
-
-    log.info(`Running ${agentName}...`);
-
-    let payload: Payload;
-
-    try {
-      // attempt JSON parsing
-      const parsedPrompt = JSON.parse(inputs.prompt);
-      if (!("~pullfrog" in parsedPrompt)) {
-        // is non-pullfrog JSON (probably from a GitHub event), treat it as a plain text prompt
-        throw new Error();
+function setupMcpLogPolling(ctx: MainContext): void {
+  let lastSize = 0;
+  ctx.pollInterval = setInterval(() => {
+    if (existsSync(ctx.mcpLogPath)) {
+      const content = readFileSync(ctx.mcpLogPath, "utf-8");
+      if (content.length > lastSize) {
+        const newContent = content.slice(lastSize);
+        process.stdout.write(newContent);
+        lastSize = content.length;
       }
-      payload = parsedPrompt as Payload;
-    } catch {
-      payload = {
-        "~pullfrog": true,
-        agent: null,
-        prompt: inputs.prompt,
-        event: {},
-        modes,
-      };
     }
+  }, 100);
+}
 
-    log.box(payload.prompt, { title: "Prompt" });
-
-    const matchingInputKey = agent.inputKeys.find((inputKey) => inputs[inputKey]);
-
-    if (!matchingInputKey) {
-      throwMissingApiKeyError({
-        agentName,
-        inputKeys: agent.inputKeys,
-        repoContext,
-        inputs,
-      });
+function parsePayload(inputs: Inputs): Payload {
+  try {
+    const parsedPrompt = JSON.parse(inputs.prompt);
+    if (!("~pullfrog" in parsedPrompt)) {
+      throw new Error();
     }
-
-    const apiKey = inputs[matchingInputKey]!;
-
-    const result = await agent.run({
-      payload,
-      mcpServers,
-      githubInstallationToken,
-      apiKey,
-      cliPath,
-    });
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || "Agent execution failed",
-        output: result.output!,
-      };
-    }
-
-    log.success("Task complete.");
-    await log.writeSummary();
-
+    return parsedPrompt as Payload;
+  } catch {
     return {
-      success: true,
-      output: result.output || "",
+      "~pullfrog": true,
+      agent: null,
+      prompt: inputs.prompt,
+      event: {},
+      modes,
     };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-    log.error(errorMessage);
-    await log.writeSummary();
-    return {
-      success: false,
-      error: errorMessage,
-    };
-  } finally {
-    if (tokenToRevoke) {
-      await revokeInstallationToken(tokenToRevoke);
-    }
+  }
+}
+
+function setupMcpServers(ctx: MainContext): void {
+  const allModes = [...modes, ...(ctx.payload.modes || [])];
+  ctx.mcpServers = createMcpConfigs(ctx.githubInstallationToken, allModes);
+  log.debug(`📋 MCP Config: ${JSON.stringify(ctx.mcpServers, null, 2)}`);
+}
+
+async function installAgentCli(ctx: MainContext): Promise<void> {
+  ctx.cliPath = await ctx.agent.install();
+}
+
+function validateApiKey(ctx: MainContext): void {
+  const matchingInputKey = ctx.agent.inputKeys.find(
+    (inputKey: string) => ctx.inputs[inputKey as AgentInputKey]
+  );
+  if (!matchingInputKey) {
+    throwMissingApiKeyError({
+      agentName: ctx.agentName,
+      inputKeys: ctx.agent.inputKeys,
+      repoContext: ctx.repoContext,
+      inputs: ctx.inputs,
+    });
+  }
+  ctx.apiKey = ctx.inputs[matchingInputKey as AgentInputKey]!;
+}
+
+async function runAgent(ctx: MainContext): Promise<import("./agents/shared.ts").AgentResult> {
+  log.info(`Running ${ctx.agentName}...`);
+  log.box(ctx.payload.prompt, { title: "Prompt" });
+
+  return ctx.agent.run({
+    payload: ctx.payload,
+    mcpServers: ctx.mcpServers,
+    githubInstallationToken: ctx.githubInstallationToken,
+    apiKey: ctx.apiKey,
+    cliPath: ctx.cliPath,
+  });
+}
+
+async function handleAgentResult(
+  result: import("./agents/shared.ts").AgentResult
+): Promise<MainResult> {
+  if (!result.success) {
+    return {
+      success: false,
+      error: result.error || "Agent execution failed",
+      output: result.output!,
+    };
+  }
+
+  log.success("Task complete.");
+  await log.writeSummary();
+
+  return {
+    success: true,
+    output: result.output || "",
+  };
+}
+
+async function cleanup(
+  ctx: Omit<MainContext, "payload" | "mcpServers" | "cliPath" | "apiKey">
+): Promise<void> {
+  if (ctx.pollInterval) {
+    clearInterval(ctx.pollInterval);
+  }
+  if (ctx.tokenToRevoke) {
+    await revokeInstallationToken(ctx.tokenToRevoke);
   }
 }

mcp/comment.ts

@@ -77,7 +77,7 @@ export const CreateWorkingCommentTool = tool({
       owner: ctx.owner,
       repo: ctx.name,
       issue_number: issueNumber,
-      body: intent,
+      body: `${intent} <img src="https://pullfrog.ai/party-parrot.gif" width="14px" height="14px" style="vertical-align: middle; margin-left: 4px;" />`,
     });
 
     workingCommentId = result.data.id;

mcp/config.ts

@@ -2,23 +2,23 @@
  * Simple MCP configuration helper for adding our minimal GitHub comment server
  */
 
-import type { McpServerConfig, McpStdioServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import type { McpStdioServerConfig } from "@anthropic-ai/claude-agent-sdk";
 import { fromHere } from "@ark/fs";
-import { log } from "../utils/cli.ts";
+import { ghPullfrogMcpName } from "../external.ts";
+import type { Mode } from "../modes.ts";
 import { parseRepoContext } from "../utils/github.ts";
-import { ghPullfrogMcpName } from "./index.ts";
 
 export type McpName = typeof ghPullfrogMcpName;
 
 export type McpConfigs = Record<McpName, McpStdioServerConfig>;
 
-export function createMcpConfigs(githubInstallationToken: string): McpConfigs {
+export function createMcpConfigs(githubInstallationToken: string, modes: Mode[]): McpConfigs {
   const repoContext = parseRepoContext();
   const githubRepository = `${repoContext.owner}/${repoContext.name}`;
 
-  // In production (GitHub Actions), mcp-server.js is in same directory as entry.js (where this is bundled)
+  // In production (GitHub Actions), mcp-server is in same directory as entry.js (where this is bundled)
   // In development, server.ts is in the same directory as this file (config.ts)
-  const serverPath = process.env.GITHUB_ACTIONS ? fromHere("mcp-server.js") : fromHere("server.ts");
+  const serverPath = process.env.GITHUB_ACTIONS ? fromHere("mcp-server") : fromHere("server.ts");
 
   return {
     [ghPullfrogMcpName]: {
@@ -27,25 +27,8 @@ export function createMcpConfigs(githubInstallationToken: string): McpConfigs {
       env: {
         GITHUB_INSTALLATION_TOKEN: githubInstallationToken,
         GITHUB_REPOSITORY: githubRepository,
+        PULLFROG_MODES: JSON.stringify(modes),
       },
     },
   };
 }
-
-/**
- * Iterate through MCP servers and call the provided handler for each stdio server
- * Shared logic to avoid duplication across agents
- */
-export function forEachStdioMcpServer(
-  mcpServers: Record<string, McpServerConfig>,
-  handler: (serverName: string, serverConfig: McpStdioServerConfig) => void
-): void {
-  for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
-    // Only configure stdio servers (CLIs support stdio MCP servers)
-    if (!("command" in serverConfig)) {
-      log.warning(`MCP server '${serverName}' is not a stdio server, skipping...`);
-      continue;
-    }
-    handler(serverName, serverConfig);
-  }
-}

mcp/index.ts

@@ -1,4 +1,2 @@
-// for reasos this can't live alongide config.ts
-// because its imported into the frontend UI
-// and we don't want to pull in FastMCP, etc
-export const ghPullfrogMcpName = "gh-pullfrog";
+// re-export from external.ts for backward compatibility
+export { ghPullfrogMcpName } from "../external.ts";

mcp/selectMode.ts

@@ -0,0 +1,55 @@
+import { type } from "arktype";
+import type { Mode } from "../modes.ts";
+import { contextualize, tool } from "./shared.ts";
+
+// Get modes from environment variable (set by createMcpConfigs)
+function getModes(): Mode[] {
+  const modesJson = process.env.PULLFROG_MODES;
+  if (modesJson) {
+    try {
+      return JSON.parse(modesJson);
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+
+export const SelectMode = type({
+  modeName: type.string.describe(
+    "the name of the mode to select (e.g., 'Plan', 'Build', 'Review', 'Prompt')"
+  ),
+});
+
+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 }) => {
+    const allModes = getModes();
+
+    if (allModes.length === 0) {
+      return {
+        error:
+          "No modes available. Modes must be provided via PULLFROG_MODES environment variable.",
+      };
+    }
+
+    const selectedMode = allModes.find((m) => m.name.toLowerCase() === modeName.toLowerCase());
+
+    if (!selectedMode) {
+      const availableModes = allModes.map((m) => m.name).join(", ");
+      return {
+        error: `Mode "${modeName}" not found. Available modes: ${availableModes}`,
+        availableModes: allModes.map((m) => ({ name: m.name, description: m.description })),
+      };
+    }
+
+    return {
+      modeName: selectedMode.name,
+      description: selectedMode.description,
+      prompt: selectedMode.prompt,
+    };
+  }),
+});

mcp/server.ts

@@ -1,5 +1,3 @@
-#!/usr/bin/env node
-// Minimal GitHub Issue Comment MCP Server
 import { FastMCP } from "fastmcp";
 import {
   CreateCommentTool,
@@ -11,6 +9,7 @@ import { IssueTool } from "./issue.ts";
 import { PullRequestTool } from "./pr.ts";
 import { PullRequestInfoTool } from "./prInfo.ts";
 import { ReviewTool } from "./review.ts";
+import { SelectModeTool } from "./selectMode.ts";
 import { addTools } from "./shared.ts";
 
 const server = new FastMCP({
@@ -19,6 +18,7 @@ const server = new FastMCP({
 });
 
 addTools(server, [
+  SelectModeTool,
   CreateCommentTool,
   EditCommentTool,
   CreateWorkingCommentTool,

mcp/shared.ts

@@ -1,9 +1,8 @@
-import { appendFileSync } from "node:fs";
-import { join } from "node:path";
 import { cached } from "@ark/util";
 import { Octokit } from "@octokit/rest";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { FastMCP, Tool } from "fastmcp";
+import { log } from "../utils/cli.ts";
 import { parseRepoContext, type RepoContext } from "../utils/github.ts";
 
 export interface ToolResult {
@@ -32,49 +31,6 @@ export interface McpContext extends RepoContext {
   octokit: Octokit;
 }
 
-/**
- * Get the log file path
- */
-function getLogPath(): string {
-  return join(process.cwd(), "log.txt");
-}
-
-/**
- * Log MCP tool call information to log.txt
- */
-function logToolCall({
-  toolName,
-  request,
-  error,
-  success,
-}: {
-  toolName: string;
-  request: unknown;
-  error?: unknown;
-  success?: boolean;
-}) {
-  const logPath = getLogPath();
-  const timestamp = new Date().toISOString();
-  const requestStr = JSON.stringify(request, null, 2);
-
-  let logEntry = `[${timestamp}] Tool: ${toolName}\nRequest: ${requestStr}\n`;
-
-  if (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const errorStack = error instanceof Error ? error.stack : undefined;
-    logEntry += `Error: ${errorMessage}\n`;
-    if (errorStack) {
-      logEntry += `Stack: ${errorStack}\n`;
-    }
-    logEntry += `Status: FAILED\n`;
-  } else if (success !== undefined) {
-    logEntry += `Status: ${success ? "SUCCESS" : "FAILED"}\n`;
-  }
-
-  logEntry += `${"=".repeat(80)}\n\n`;
-  appendFileSync(logPath, logEntry, "utf-8");
-}
-
 export const tool = <const params>(toolDef: Tool<any, StandardSchemaV1<params>>) => {
   // Wrap the execute function to add logging with the tool name
   const toolName = toolDef.name;
@@ -82,15 +38,26 @@ export const tool = <const params>(toolDef: Tool<any, StandardSchemaV1<params>>)
 
   toolDef.execute = async (args: params, context: any) => {
     try {
-      logToolCall({ toolName, request: args });
       const result = await originalExecute(args, context);
       // Check if result is a ToolResult with isError property
       const isError =
         result && typeof result === "object" && "isError" in result && result.isError === true;
-      logToolCall({ toolName, request: args, success: !isError });
+      const resultData =
+        result && typeof result === "object" && "content" in result
+          ? (result as ToolResult).content[0]?.text
+          : undefined;
+
+      if (isError && resultData) {
+        log.toolCall({ toolName, request: args, error: resultData });
+      } else if (resultData) {
+        log.toolCall({ toolName, request: args, result: resultData });
+      } else {
+        log.toolCall({ toolName, request: args });
+      }
       return result;
     } catch (error) {
-      logToolCall({ toolName, request: args, error });
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log.toolCall({ toolName, request: args, error: errorMessage });
       throw error;
     }
   };

modes.ts

@@ -1,4 +1,4 @@
-import { ghPullfrogMcpName } from "./mcp/index.ts";
+import { ghPullfrogMcpName } from "./external.ts";
 
 export interface Mode {
   name: string;
@@ -6,13 +6,16 @@ export interface Mode {
   prompt: string;
 }
 
+const initialCommentInstruction = `Use ${ghPullfrogMcpName}/create_working_comment to create an initial Working Comment that contains a SENTENCE FRAGMENT that casually describes the actions you're about to perform. It must be of the form "Starting work on this issue...". You MUST use an -ing verb!`;
+
 export const modes: Mode[] = [
   {
     name: "Plan",
     description:
       "Create plans, break down tasks, outline steps, analyze requirements, understand scope of work, or provide task breakdowns",
     prompt: `Follow these steps:
-1. Create initial response comment using ${ghPullfrogMcpName}/create_working_comment saying "I'll {summary of request}"
+1. ${initialCommentInstruction}
+    
 2. If the request requires understanding the codebase structure, dependencies, or conventions, gather relevant context (read AGENTS.md if it exists, understand how to install dependencies, run tests, run builds, and make changes according to best practices). Skip this step if the prompt is trivial and self-contained.
 3. Analyze the request and break it down into clear, actionable tasks
 4. Consider dependencies, potential challenges, and implementation order
@@ -25,7 +28,8 @@ export const modes: Mode[] = [
     description:
       "Implement, build, create, or develop code changes; make specific changes to files or features; execute a plan; or handle tasks with specific implementation details",
     prompt: `Follow these steps:
-1. Create initial response comment using ${ghPullfrogMcpName}/create_working_comment saying "I'll {summary of request}"
+1. ${initialCommentInstruction}
+    
 2. If the request requires understanding the codebase structure, dependencies, or conventions, gather relevant context (read AGENTS.md if it exists, understand how to install dependencies, run tests, run builds, and make changes according to best practices). Skip this step if the prompt is trivial and self-contained.
 3. Understand the requirements and any existing plan
 4. Make the necessary code changes
@@ -38,7 +42,8 @@ export const modes: Mode[] = [
     description:
       "Review code, PRs, or implementations; provide feedback or suggestions; identify issues; or check code quality, style, and correctness",
     prompt: `Follow these steps:
-1. Create initial response comment using ${ghPullfrogMcpName}/create_working_comment saying "I'll review this"
+1. ${initialCommentInstruction}
+    
 2. Get PR info with ${ghPullfrogMcpName}/get_pull_request (this automatically prepares the repository by fetching and checking out the PR branch)
 3. View diff: git diff origin/<base>...origin/<head> (use line numbers from this for inline comments, replace <base> and <head> with 'base' and 'head' from PR info)
 4. Read files from the checked-out PR branch to understand the implementation
@@ -52,7 +57,8 @@ export const modes: Mode[] = [
     description:
       "Fallback for tasks that don't fit other workflows, direct prompts via comments, or requests requiring general assistance without a specific workflow pattern",
     prompt: `Follow these steps:
-1. Create an initial "Working Comment" using ${ghPullfrogMcpName}/create_working_comment saying "I'll {summary of request}"
+1. ${initialCommentInstruction}
+    
 2. Perform the requested task. Only take action if you have high confidence that you understand what is being asked. If you are not sure, ask for clarification. Take stock of the tools at your disposal.
 3. As your work progresses, update your Working Comment to share progress and results using ${ghPullfrogMcpName}/update_working_comment. Do not create additional comments unless you are explicitly asked to do so.
 4. When you finish the task, update the Working Comment a final time with a summary of the results and links to any created issues, PRs, etc.`,

package.json

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

todo.md

@@ -3,10 +3,6 @@
 [] gemini installation speed (bundle/esm.sh?) (TODO: SHAWN)
 [] handle defaulting agent name value (TODO: SHAWN)
 
-[] split up prompts, load dynamically based on mode
-[] log.txt to stdout
-
-[] entry.js
 [] test agent/mode combinations
 [] test if home directory mcp.json works if mcp.json is specified in repo
 [] add footer to the working comment ("executed by {agent}", link to pullfrog (homepage) w/ small logo?, feedback (create github issue), link to workflow run)- see https://github.com/colinhacks/zod/issues/5459#issuecomment-3548382991
@@ -33,3 +29,6 @@
 [x] handle progressive comment updating from pullfrog mcp
 [x] jules/gemini support
 [x] standardize mcp server
+[x] entry.js
+[x] split up prompts, load dynamically based on mode
+[x] log.txt to stdout

utils/api.ts

@@ -1,4 +1,4 @@
-import type { AgentName } from "../main.ts";
+import type { AgentName } from "../external.ts";
 import { log } from "./cli.ts";
 import type { RepoContext } from "./github.ts";
 

utils/cli.ts

@@ -2,9 +2,11 @@
  * CLI output utilities that work well in both local and GitHub Actions environments
  */
 
+import { spawnSync } from "node:child_process";
+import { appendFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
 import * as core from "@actions/core";
-import { spawnSync } from "child_process";
-import { existsSync } from "fs";
+import { table } from "table";
 
 const isGitHubActions = !!process.env.GITHUB_ACTIONS;
 const isDebugEnabled = process.env.LOG_LEVEL === "debug";
@@ -159,6 +161,43 @@ async function summaryTable(
   core.info(`\n${tableText}\n`);
 }
 
+/**
+ * Print a formatted table using the table package
+ * Also logs to console and GitHub Actions summary
+ */
+async function printTable(
+  rows: Array<Array<{ data: string; header?: boolean } | string>>,
+  options?: {
+    title?: string;
+  }
+): Promise<void> {
+  const { title } = options || {};
+
+  // Convert rows to string arrays for the table package
+  const tableData = rows.map((row) =>
+    row.map((cell) => {
+      if (typeof cell === "string") {
+        return cell;
+      }
+      return cell.data;
+    })
+  );
+
+  const formatted = table(tableData);
+
+  if (title) {
+    core.info(`\n${title}`);
+  }
+  core.info(`\n${formatted}\n`);
+
+  if (isGitHubActions) {
+    if (title) {
+      core.summary.addRaw(`**${title}**\n\n`);
+    }
+    core.summary.addRaw(`\`\`\`\n${formatted}\n\`\`\`\n`);
+  }
+}
+
 /**
  * Print a separator line
  */
@@ -239,6 +278,11 @@ export const log = {
    */
   summaryTable,
 
+  /**
+   * Print a formatted table using the table package
+   */
+  table: printTable,
+
   /**
    * Print a separator line
    */
@@ -263,8 +307,119 @@ export const log = {
    * End a collapsed group
    */
   endGroup,
+
+  /**
+   * Log MCP tool call information to mcpLog.txt in the temp directory
+   */
+  toolCall: ({
+    toolName,
+    request,
+    result,
+    error,
+  }: {
+    toolName: string;
+    request: unknown;
+    result?: string;
+    error?: string;
+  }): void => {
+    const logPath = getMcpLogPath();
+    const params: Parameters<typeof formatToolCall>[0] = { toolName, request };
+    if (error) {
+      params.error = error;
+    } else if (result) {
+      params.result = result;
+    }
+    const logEntry = formatToolCall(params);
+    appendFileSync(logPath, logEntry, "utf-8");
+  },
 };
 
+/**
+ * Get the path to the MCP log file in the temp directory
+ */
+function getMcpLogPath(): string {
+  const tempDir = process.env.PULLFROG_TEMP_DIR!;
+  return join(tempDir, "mcpLog.txt");
+}
+
+/**
+ * Format a value as JSON, using compact format for simple values and pretty-printed for complex ones
+ */
+function formatJsonValue(value: unknown): string {
+  const compact = JSON.stringify(value);
+  return compact.length > 80 || compact.includes("\n") ? JSON.stringify(value, null, 2) : compact;
+}
+
+/**
+ * Format a multi-line string with proper indentation for tool call output
+ * First line has the label, subsequent lines are indented 4 spaces
+ */
+function formatIndentedField(label: string, content: string): string {
+  if (!content.includes("\n")) {
+    return `  ${label}: ${content}\n`;
+  }
+
+  const lines = content.split("\n");
+  let formatted = `  ${label}: ${lines[0]}\n`;
+  for (let i = 1; i < lines.length; i++) {
+    formatted += `    ${lines[i]}\n`;
+  }
+  return formatted;
+}
+
+/**
+ * Format the input field for a tool call
+ */
+function formatToolInput(request: unknown): string {
+  const requestFormatted = formatJsonValue(request);
+  if (requestFormatted === "{}") {
+    return "";
+  }
+  return formatIndentedField("input", requestFormatted);
+}
+
+/**
+ * Format the result field for a tool call, parsing JSON if possible
+ */
+function formatToolResult(result: string): string {
+  try {
+    const parsed = JSON.parse(result);
+    const formatted = formatJsonValue(parsed);
+    return formatIndentedField("result", formatted);
+  } catch {
+    // Not JSON, display as-is
+    return formatIndentedField("result", result);
+  }
+}
+
+/**
+ * Format a complete tool call entry with tool name, input, result, and error
+ */
+function formatToolCall({
+  toolName,
+  request,
+  result,
+  error,
+}: {
+  toolName: string;
+  request: unknown;
+  result?: string;
+  error?: string;
+}): string {
+  let logEntry = `→ ${toolName}\n`;
+
+  logEntry += formatToolInput(request);
+
+  if (error) {
+    logEntry += formatIndentedField("error", error);
+  } else if (result) {
+    logEntry += formatToolResult(result);
+  }
+
+  logEntry += "\n";
+  return logEntry;
+}
+
 /**
  * Finds a CLI executable path by checking if it's installed globally
  * @param name The name of the CLI executable to find