fix bundle import

.husky/pre-commit

@@ -0,0 +1,10 @@
+# Ensure lockfile is up to date
+echo "🔒 Updating lockfile..."
+pnpm install --lockfile-only
+
+# Build the action before committing
+echo "🔨 Building action..."
+pnpm build
+
+# Add the built files and lockfile to the commit
+git add entry.js pnpm-lock.yaml

README.md

@@ -12,69 +12,13 @@ pnpm install
 
 # Test with default prompt
 npm run play              # Run locally on your machine
-npm run play -- --act     # Run in Docker (simulates GitHub Actions)
 ```
 
 ## Testing with play.ts
 
-The `play.ts` script provides two ways to test the action:
-
-### Local Mode (Default)
 ```bash
-npm run play                        # Uses fixtures/play.txt
-npm run play fixtures/complex.txt   # Custom prompt file
+pnpm play                        # Uses fixtures/play.txt
 ```
 - Clones the scratch repository to `.temp`
 - Runs Claude Code directly on your machine
 - Fast iteration for development
-
-### Docker Mode (--act flag)
-```bash
-npm run play -- --act                        # Uses fixtures/play.txt
-npm run play fixtures/simple.txt -- --act    # Custom prompt file
-```
-- Builds fresh bundles with esbuild
-- Creates minimal distribution without node_modules
-- Runs in Docker container via `act`
-- Simulates GitHub Actions environment
-
-### Prompt Files
-
-Supports `.txt`, `.json`, and `.ts` files:
-```bash
-npm run play prompt.txt           # Plain text prompt
-npm run play config.json          # JSON configuration
-npm run play dynamic.ts           # TypeScript with default export
-```
-
-## Building
-
-```bash
-pnpm build        # Production build (bundles & removes node_modules)
-pnpm build:dev    # Development build (keeps node_modules)
-pnpm dev          # Watch mode
-```
-
-The action is bundled into `entry.cjs` with all dependencies included, eliminating runtime dependency on node_modules.
-
-## Environment Variables
-
-Create `.env` in `/action`:
-
-```bash
-ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  # Claude API key
-```
-
-## Architecture
-
-- **entry.cjs**: Bundled action entry point (self-contained)
-- **agents/**: Agent implementations (Claude, etc.)
-- **utils/**: Utilities for subprocess, act, and formatting
-- **fixtures/**: Test prompt files
-
-## Why No node_modules?
-
-pnpm uses symlinks that cause "invalid symlink" errors when `act` copies the action to Docker. Our solution:
-1. Bundle everything into `entry.cjs` 
-2. Remove node_modules after building
-3. Create minimal `.act-dist` for Docker testing

action.yml

@@ -12,31 +12,8 @@ inputs:
     required: false
 
 runs:
-  using: "composite"
-  steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 1
-    - name: Setup pnpm
-      uses: pnpm/action-setup@v4
-      with:
-        version: latest
-    - name: Setup Node.js 24
-      uses: actions/setup-node@v4
-      with:
-        node-version: "24"
-        cache: "pnpm"
-    - name: Install dependencies
-      run: pnpm install
-      shell: bash
-      working-directory: ${{ github.action_path }}
-    - name: Run agent
-      run: node entry.ts
-      shell: bash
-      working-directory: ${{ github.action_path }}
-      env:
-        INPUTS_JSON: ${{ toJSON(inputs) }}
+  using: "node20"
+  main: "entry.js"
 
 branding:
   icon: "code"

agents/claude.ts

@@ -1,319 +1,244 @@
-import { access, constants } from "node:fs/promises";
-import * as core from "@actions/core";
-import { createMcpConfig } from "../mcp/config.ts";
-import { spawn } from "../utils/subprocess.ts";
-import { boxString, tableString } from "../utils/table.ts";
-import { instructions } from "./shared.ts";
-import type { Agent, AgentConfig, AgentResult } from "./types.ts";
+import { execSync } from "node:child_process";
+import { createWriteStream, existsSync, rmSync } 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 { query, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import packageJson from "../package.json" with { type: "json" };
+import { log } from "../utils/cli.ts";
+import { type Agent, instructions } from "./shared.ts";
 
-/**
- * Claude Code agent implementation
- */
-export class ClaudeAgent implements Agent {
-  private apiKey: string;
-  private githubInstallationToken: string;
-  public runStats = {
-    toolsUsed: 0,
-    turns: 0,
-    startTime: 0,
-  };
+let cachedCliPath: string | undefined;
 
-  constructor(config: AgentConfig) {
-    this.apiKey = config.apiKey;
-    this.githubInstallationToken = config.githubInstallationToken;
-  }
-
-  /**
-   * Check if Claude Code CLI is already installed
-   */
-  private async isClaudeInstalled(): Promise<boolean> {
-    try {
-      const claudePath = `${process.env.HOME}/.local/bin/claude`;
-      await access(claudePath, constants.F_OK | constants.X_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Install Claude Code CLI
-   */
-  async install(): Promise<void> {
-    if (await this.isClaudeInstalled()) {
-      core.info("Claude Code is already installed, skipping installation");
-      return;
+export const claude: Agent = {
+  install: async (): Promise<string> => {
+    if (cachedCliPath) {
+      log.info(`Using cached Claude Code CLI at ${cachedCliPath}`);
+      return cachedCliPath;
     }
 
-    core.info("Installing Claude Code...");
-    try {
-      const result = await spawn({
-        cmd: "bash",
-        args: ["-c", "curl -fsSL https://claude.ai/install.sh | bash -s 1.0.93"],
-        env: { ANTHROPIC_API_KEY: this.apiKey },
-        timeout: 120000, // 2 minute timeout
-        onStdout: () => {},
-        onStderr: (chunk) => process.stderr.write(chunk),
-      });
+    // Get the SDK version from package.json and resolve to actual version
+    const versionRange = packageJson.dependencies["@anthropic-ai/claude-agent-sdk"] || "latest";
+    let sdkVersion: string;
 
-      if (result.exitCode !== 0) {
-        throw new Error(`Installation failed with exit code ${result.exitCode}: ${result.stderr}`);
-      }
-
-      core.info("Claude Code installed successfully");
-    } catch (error) {
-      throw new Error(`Failed to install Claude Code: ${error}`);
-    }
-  }
-
-  /**
-   * Execute Claude Code with the given prompt
-   */
-  async execute(prompt: string): Promise<AgentResult> {
-    core.info("Running Claude Code...");
-
-    try {
-      const claudePath = `${process.env.HOME}/.local/bin/claude`;
-
-      const env = {
-        ANTHROPIC_API_KEY: this.apiKey,
-      };
-
-      console.log(boxString(prompt, { title: "Prompt" }));
-
-      const mcpConfig = createMcpConfig(this.githubInstallationToken);
-      console.log("📋 MCP Config:", mcpConfig);
-
-      const args = [
-        "--print",
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--debug",
-        "--permission-mode",
-        "bypassPermissions",
-        "--mcp-config",
-        mcpConfig,
-      ];
-
-      core.startGroup("🔄 Run details");
-
-      this.runStats = {
-        toolsUsed: 0,
-        turns: 0,
-        startTime: Date.now(),
-      };
-
-      const finalResult = "";
-      const totalCost = 0;
-
-      const result = await spawn({
-        cmd: claudePath,
-        args,
-        env,
-        input: `${instructions} ${prompt}`,
-        timeout: 10 * 60 * 1000, // 10 minutes
-        onStdout: (_chunk) => {
-          processJSONChunk(_chunk, this);
-        },
-        onStderr: (_chunk) => {
-          if (_chunk.trim()) {
-            processJSONChunk(_chunk, this);
-          }
-        },
-      });
-
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `Command failed with exit code ${result.exitCode}\n\nStdout: ${result.stdout}\n\nStderr: ${result.stderr}`
-        );
-      }
-
-      const duration = Date.now() - this.runStats.startTime;
-      core.info(
-        `📊 Run Summary: ${this.runStats.toolsUsed} tools used, ${this.runStats.turns} turns, ${duration}ms duration`
-      );
-
-      core.info("✅ Task complete.");
-      core.endGroup(); // End the collapsible log group
-
-      return {
-        success: true,
-        output: finalResult,
-        metadata: {
-          promptLength: prompt.length,
-          exitCode: result.exitCode,
-          durationMs: result.durationMs,
-          totalCost,
-        },
-      };
-    } catch (error: any) {
+    // If it's a range (starts with ^ or ~), query npm registry for the latest matching version
+    if (versionRange.startsWith("^") || versionRange.startsWith("~")) {
+      const npmRegistry = process.env.NPM_REGISTRY || "https://registry.npmjs.org";
+      log.info(`Resolving version for range ${versionRange}...`);
       try {
-        core.endGroup();
-      } catch {}
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        success: false,
-        error: `Failed to execute Claude Code: ${errorMessage}`,
-      };
-    }
-  }
-}
-
-/**
- * Pretty print a JSON chunk based on its type
- */
-function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
-  try {
-    // Skip debug lines that start with [DEBUG] or [debug]
-    const trimmedChunk = chunk.trim();
-    if (trimmedChunk.startsWith("[DEBUG]") || trimmedChunk.startsWith("[debug]")) {
-      console.log(chunk);
-      return;
-    }
-    
-    console.log(chunk);
-    const parsedChunk = JSON.parse(trimmedChunk);
-
-    switch (parsedChunk.type) {
-      case "system":
-        if (parsedChunk.subtype === "init") {
-          core.info(`🚀 Starting Claude Code session...`);
-          core.info(
-            tableString([
-              ["model", parsedChunk.model],
-              ["cwd", parsedChunk.cwd],
-              ["permission_mode", parsedChunk.permissionMode],
-              ["tools", parsedChunk.tools?.length ? `${parsedChunk.tools.length} tools` : "none"],
-              [
-                "mcp_servers",
-                parsedChunk.mcp_servers?.length
-                  ? `${parsedChunk.mcp_servers.length} servers`
-                  : "none",
-              ],
-              [
-                "slash_commands",
-                parsedChunk.slash_commands?.length
-                  ? `${parsedChunk.slash_commands.length} commands`
-                  : "none",
-              ],
-            ])
-          );
+        const registryResponse = await fetch(`${npmRegistry}/@anthropic-ai/claude-agent-sdk`);
+        if (!registryResponse.ok) {
+          throw new Error(`Failed to query registry: ${registryResponse.status}`);
         }
-        break;
+        const registryData = (await registryResponse.json()) as {
+          "dist-tags": { latest: string };
+          versions: Record<string, unknown>;
+        };
+        // Get the latest version that matches the range (simplified: just use latest)
+        sdkVersion = registryData["dist-tags"].latest;
+        log.info(`Resolved to version ${sdkVersion}`);
+      } catch (error) {
+        log.warning(
+          `Failed to resolve version from registry, using latest: ${error instanceof Error ? error.message : String(error)}`
+        );
+        sdkVersion = "latest";
+      }
+    } else {
+      sdkVersion = versionRange;
+    }
 
-      case "assistant":
-        if (parsedChunk.message?.content) {
-          if (agent) {
-            agent.runStats.turns++;
+    log.info(`📦 Installing Claude Code CLI from @anthropic-ai/claude-agent-sdk@${sdkVersion}...`);
+
+    // Create temp directory
+    const tempDir = await mkdtemp(join(tmpdir(), "claude-cli-"));
+    const tarballPath = join(tempDir, "package.tgz");
+
+    try {
+      // Download tarball from npm
+      const npmRegistry = process.env.NPM_REGISTRY || "https://registry.npmjs.org";
+      const tarballUrl = `${npmRegistry}/@anthropic-ai/claude-agent-sdk/-/claude-agent-sdk-${sdkVersion}.tgz`;
+
+      log.info(`Downloading from ${tarballUrl}...`);
+      const response = await fetch(tarballUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to download tarball: ${response.status} ${response.statusText}`);
+      }
+
+      // Write tarball to file
+      const fileStream = createWriteStream(tarballPath);
+      await pipeline(response.body as any, fileStream);
+      log.info(`Downloaded tarball to ${tarballPath}`);
+
+      // Extract tarball
+      log.info(`Extracting tarball...`);
+      execSync(`tar -xzf "${tarballPath}" -C "${tempDir}"`, { stdio: "pipe" });
+
+      // Find cli.js in the extracted package
+      const extractedDir = join(tempDir, "package");
+      const cliPath = join(extractedDir, "cli.js");
+
+      if (!existsSync(cliPath)) {
+        throw new Error(`cli.js not found in extracted package at ${cliPath}`);
+      }
+
+      cachedCliPath = cliPath;
+      log.info(`✓ Claude Code CLI installed at ${cliPath}`);
+      return cliPath;
+    } catch (error) {
+      // Cleanup on error
+      try {
+        rmSync(tempDir, { recursive: true, force: true });
+      } catch {
+        // Ignore cleanup errors
+      }
+      throw error;
+    }
+  },
+  run: async ({ prompt, mcpServers, apiKey }) => {
+    process.env.ANTHROPIC_API_KEY = apiKey;
+
+    if (!cachedCliPath) {
+      throw new Error("Claude CLI not installed. Call install() before run().");
+    }
+
+    const queryInstance = query({
+      prompt: `${instructions}\n\n****** USER PROMPT ******\n${prompt}`,
+      options: {
+        permissionMode: "bypassPermissions",
+        mcpServers,
+        pathToClaudeCodeExecutable: cachedCliPath,
+      },
+    });
+
+    // Stream the results
+    for await (const message of queryInstance) {
+      const handler = messageHandlers[message.type];
+      await handler(message as never);
+    }
+
+    return {
+      success: true,
+      output: "",
+    };
+  },
+};
+
+type SDKMessageType = SDKMessage["type"];
+
+type SDKMessageHandler<type extends SDKMessageType = SDKMessageType> = (
+  data: Extract<SDKMessage, { type: type }>
+) => void | Promise<void>;
+
+type SDKMessageHandlers = {
+  [type in SDKMessageType]: SDKMessageHandler<type>;
+};
+
+// Track bash tool IDs to identify when bash tool results come back
+const bashToolIds = new Set<string>();
+
+const messageHandlers: SDKMessageHandlers = {
+  assistant: (data) => {
+    if (data.message?.content) {
+      for (const content of data.message.content) {
+        if (content.type === "text" && content.text?.trim()) {
+          log.box(content.text.trim(), { title: "Claude" });
+        } else if (content.type === "tool_use") {
+          log.info(`→ ${content.name}`);
+
+          // Track bash tool IDs
+          if (content.name === "bash" && content.id) {
+            bashToolIds.add(content.id);
           }
 
-          for (const content of parsedChunk.message.content) {
-            if (content.type === "text") {
-              if (content.text.trim()) {
-                core.info(boxString(content.text.trim(), { title: "Claude Code" }));
-              }
-            } else if (content.type === "tool_use") {
-              if (agent) {
-                agent.runStats.toolsUsed++;
-              }
-
-              const toolName = content.name;
-
-              core.info(`→ ${toolName}`);
-
-              if (content.input) {
-                const input = content.input;
-
-                if (input.description) {
-                  core.info(`   └─ ${input.description}`);
-                }
-
-                if (input.command) {
-                  core.info(`   └─ command: ${input.command}`);
-                }
-
-                if (input.file_path) {
-                  core.info(`   └─ file: ${input.file_path}`);
-                }
-
-                if (input.content) {
-                  const contentPreview =
-                    input.content.length > 100
-                      ? `${input.content.substring(0, 100)}...`
-                      : input.content;
-                  core.info(`   └─ content: ${contentPreview}`);
-                }
-
-                if (input.query) {
-                  core.info(`   └─ query: ${input.query}`);
-                }
-
-                if (input.pattern) {
-                  core.info(`   └─ pattern: ${input.pattern}`);
-                }
-
-                if (input.url) {
-                  core.info(`   └─ url: ${input.url}`);
-                }
-
-                if (input.edits && Array.isArray(input.edits)) {
-                  core.info(`   └─ edits: ${input.edits.length} changes`);
-                  input.edits.forEach((edit: any, index: number) => {
-                    if (edit.file_path) {
-                      core.info(`      ${index + 1}. ${edit.file_path}`);
-                    }
-                  });
-                }
-
-                if (input.task) {
-                  core.info(`   └─ task: ${input.task}`);
-                }
-
-                if (input.bash_command) {
-                  core.info(`   └─ bash_command: ${input.bash_command}`);
-                }
-              }
+          if (content.input) {
+            const input = content.input as any;
+            if (input.description) log.info(`   └─ ${input.description}`);
+            if (input.command) log.info(`   └─ command: ${input.command}`);
+            if (input.file_path) log.info(`   └─ file: ${input.file_path}`);
+            if (input.content) {
+              const preview =
+                input.content.length > 100
+                  ? `${input.content.substring(0, 100)}...`
+                  : input.content;
+              log.info(`   └─ content: ${preview}`);
             }
-          }
-        }
-        break;
-
-      case "user":
-        if (parsedChunk.message?.content) {
-          for (const content of parsedChunk.message.content) {
-            if (content.type === "tool_result") {
-              if (content.is_error) {
-                core.warning(`❌ Tool error: ${content.content}`);
-              } else {
-              }
+            if (input.query) log.info(`   └─ query: ${input.query}`);
+            if (input.pattern) log.info(`   └─ pattern: ${input.pattern}`);
+            if (input.url) log.info(`   └─ url: ${input.url}`);
+            if (input.edits && Array.isArray(input.edits)) {
+              log.info(`   └─ edits: ${input.edits.length} changes`);
+              input.edits.forEach((edit: any, index: number) => {
+                if (edit.file_path) log.info(`      ${index + 1}. ${edit.file_path}`);
+              });
             }
+            if (input.task) log.info(`   └─ task: ${input.task}`);
+            if (input.bash_command) log.info(`   └─ bash_command: ${input.bash_command}`);
           }
         }
-        break;
-
-      case "result":
-        if (parsedChunk.subtype === "success") {
-          core.info(
-            tableString([
-              ["Cost", `$${parsedChunk.total_cost_usd?.toFixed(4) || "0.0000"}`],
-              ["Input Tokens", parsedChunk.usage?.input_tokens || 0],
-              ["Output Tokens", parsedChunk.usage?.output_tokens || 0],
-              ["Duration", `${parsedChunk.duration_ms}ms`],
-              ["Turns", parsedChunk.num_turns || 1],
-            ])
-          );
-        } else {
-          core.error(`❌ Failed: ${parsedChunk.error || "Unknown error"}`);
-        }
-        break;
-
-      default:
-        core.debug(`📦 Unknown chunk type: ${parsedChunk.type}`);
-        break;
+      }
     }
-  } catch (error) {
-    core.debug(`Failed to parse chunk: ${error}`);
-    core.debug(`Raw chunk: ${chunk.substring(0, 200)}...`);
-  }
-}
+  },
+  user: (data) => {
+    if (data.message?.content) {
+      for (const content of data.message.content) {
+        if (content.type === "tool_result") {
+          const toolUseId = (content as any).tool_use_id;
+          const isBashTool = toolUseId && bashToolIds.has(toolUseId);
+
+          if (isBashTool) {
+            // Log bash output in a collapsed group
+            const outputContent =
+              typeof content.content === "string"
+                ? content.content
+                : Array.isArray(content.content)
+                  ? content.content
+                      .map((c: any) => (typeof c === "string" ? c : c.text || JSON.stringify(c)))
+                      .join("\n")
+                  : String(content.content);
+
+            log.startGroup(`bash output`);
+            if (content.is_error) {
+              log.warning(outputContent);
+            } else {
+              log.info(outputContent);
+            }
+            log.endGroup();
+            // Clean up the tracked ID
+            bashToolIds.delete(toolUseId);
+          } else if (content.is_error) {
+            const errorContent =
+              typeof content.content === "string" ? content.content : String(content.content);
+            log.warning(`Tool error: ${errorContent}`);
+          }
+        }
+      }
+    }
+  },
+  result: async (data) => {
+    if (data.subtype === "success") {
+      await log.summaryTable([
+        [
+          { data: "Cost", header: true },
+          { data: "Input Tokens", header: true },
+          { data: "Output Tokens", header: true },
+        ],
+        [
+          `$${data.total_cost_usd?.toFixed(4) || "0.0000"}`,
+          String(data.usage?.input_tokens || 0),
+          String(data.usage?.output_tokens || 0),
+        ],
+      ]);
+    } else if (data.subtype === "error_max_turns") {
+      log.error(`Max turns reached: ${JSON.stringify(data)}`);
+    } else if (data.subtype === "error_during_execution") {
+      log.error(`Execution error: ${JSON.stringify(data)}`);
+    } else {
+      log.error(`Failed: ${JSON.stringify(data)}`);
+    }
+  },
+  system: () => {},
+  stream_event: () => {},
+  tool_progress: () => {},
+  auth_status: () => {},
+};

agents/shared.ts

@@ -1,8 +1,64 @@
-import { mcpServerName } from "../mcp/config.ts";
+import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import { ghPullfrogMcpName } from "../mcp/config.ts";
 
-export const instructions = `- use the ${mcpServerName} MCP server to interact with github
-- if ${mcpServerName} is not available or doesn't include the functionality you need, describe why and bail
-- do not under any circumstances use the gh cli
-- if prompted by a comment to respond to create a new issue, pr or anything else, after succeeding,
-    also respond to the original comment with a very brief message containing a link to it
+/**
+ * Result returned by agent execution
+ */
+export interface AgentResult {
+  success: boolean;
+  output?: string;
+  error?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Configuration for agent creation
+ */
+export interface AgentConfig {
+  apiKey: string;
+  githubInstallationToken: string;
+  prompt: string;
+  mcpServers: Record<string, McpServerConfig>;
+}
+
+export type Agent = {
+  install: () => Promise<string>;
+  run: (config: AgentConfig) => Promise<AgentResult>;
+};
+
+export const instructions = `
+You are a highly intelligent, no-nonsense senior-level software engineering agent. You are careful, to-the-point, and kind. You only say things you know to be true. Your code is focused, minimal, and production-ready. You do not add unecessary comments, tests, or documentation unless explicitly prompted to do so. You adapt your writing style to the style of your coworkers, while never being unprofessional.
+
+- eagerly inspect your MCP servers to determine what tools are available to you, especially ${ghPullfrogMcpName}
+- do not under any circumstances use the github cli (\`gh\`). find the corresponding tool from ${ghPullfrogMcpName} instead.
+- mode selection: choose the appropriate mode based on the prompt payload:
+    - choose "plan mode" if the prompt asks to:
+        - create a plan, break down tasks, outline steps, or analyze requirements
+        - understand the scope of work before implementation
+        - provide a todo list or task breakdown
+    - choose "implement" if the prompt asks to:
+        - implement, build, create, or develop code changes
+        - make specific changes to files or features
+        - execute a plan that was previously created
+        - the prompt includes specific implementation details or requirements
+    - choose "review" if the prompt asks to:
+        - review code, PR, or implementation
+        - provide feedback, suggestions, or identify issues
+        - check code quality, style, or correctness
+- once you've chosen a mode, follow its associated prompts carefully
+- when prompted directly (e.g., via issue comment or PR comment):
+    (1) start by creating a single response comment using mcp__${ghPullfrogMcpName}__create_issue_comment
+        - the initial comment should say something like "I'll do {summary of request}" where you summarize what was requested
+        - save the commentId returned from this initial comment creation
+    (2) use mcp__${ghPullfrogMcpName}__edit_issue_comment to progressively update that same comment as you make progress
+        - update the comment with current status, completed tasks, and any relevant information
+        - continue updating the same comment throughout the planning/implementation process
+    (3) create_issue_comment should only be used once initially - all subsequent updates must use edit_issue_comment with the saved commentId
+- if prompted to review a PR:
+    (1) get PR info with mcp__${ghPullfrogMcpName}__get_pull_request (this automatically prepares the repository by fetching and checking out the PR branch)
+    (2) view diff: git diff origin/<base>...origin/<head> (use line numbers from this for inline comments)
+    (3) read files from the checked-out PR branch to understand the implementation
+    (4) when submitting review: use the 'comments' array for ALL specific code issues - include the file path and line position from the diff
+    (5) only use the 'body' field for a brief summary (1-2 sentences) or for feedback that doesn't apply to a specific code location
+    replace <base> and <head> with 'base' and 'head' from the PR info
 `;

agents/types.ts

@@ -1,34 +0,0 @@
-/**
- * Standard interface for all Pullfrog agents
- */
-export interface Agent {
-  /**
-   * Install the agent and any required dependencies
-   */
-  install(): Promise<void>;
-
-  /**
-   * Execute the agent with the given prompt
-   * @param prompt The prompt to send to the agent
-   * @param options Additional options specific to the agent
-   */
-  execute(prompt: string, options?: Record<string, any>): Promise<AgentResult>;
-}
-
-/**
- * Result returned by agent execution
- */
-export interface AgentResult {
-  success: boolean;
-  output?: string;
-  error?: string;
-  metadata?: Record<string, any>;
-}
-
-/**
- * Configuration for agent creation
- */
-export interface AgentConfig {
-  apiKey: string;
-  githubInstallationToken: string;
-}

entry.ts

@@ -5,21 +5,27 @@
  */
 
 import * as core from "@actions/core";
-import { type } from "arktype";
-import { Inputs, main } from "./main.ts";
-import packageJson from "./package.json" with { type: "json" };
+import { type Inputs, main } from "./main.ts";
+import { createMcpServer } from "./mcp/server.ts";
+import { log } from "./utils/cli.ts";
+
+// Export createMcpServer so it can be called from the spawned MCP process
+export { createMcpServer };
 
 async function run(): Promise<void> {
+  // Change to GITHUB_WORKSPACE if set (this is where actions/checkout puts the repo)
+  // JavaScript actions run from the action's directory, not the checked-out repo
+  if (process.env.GITHUB_WORKSPACE && process.cwd() !== process.env.GITHUB_WORKSPACE) {
+    log.debug(`Changing to GITHUB_WORKSPACE: ${process.env.GITHUB_WORKSPACE}`);
+    process.chdir(process.env.GITHUB_WORKSPACE);
+    log.debug(`New working directory: ${process.cwd()}`);
+  }
+
   try {
-    console.log(`🐸 Running pullfrog/action@${packageJson.version}...`);
-
-    const inputsJson = process.env.INPUTS_JSON;
-    if (!inputsJson) {
-      throw new Error("INPUTS_JSON environment variable not found");
-    }
-
-    const parsed = type("string.json.parse").assert(inputsJson);
-    const inputs = Inputs.assert(parsed);
+    const inputs: Inputs = {
+      prompt: core.getInput("prompt", { required: true }),
+      anthropic_api_key: core.getInput("anthropic_api_key") || undefined,
+    };
 
     const result = await main(inputs);
 

esbuild.config.js

@@ -0,0 +1,33 @@
+import { build } from "esbuild";
+
+// Build the GitHub Action bundle only
+// For npm package builds, use zshy (pnpm build:npm)
+await build({
+  entryPoints: ["./entry.ts"],
+  bundle: true,
+  outfile: "./entry.js",
+  format: "esm",
+  platform: "node",
+  target: "node20",
+  minify: false,
+  sourcemap: false,
+  // Bundle all dependencies - GitHub Actions doesn't have node_modules
+  // Only mark optional peer dependencies as external
+  external: [
+    "@valibot/to-json-schema",
+    "effect",
+    "sury",
+  ],
+  // Provide a proper require shim for CommonJS modules bundled into ESM
+  // We use a unique variable name to avoid conflicts with bundled imports
+  banner: {
+    js: `import { createRequire as __createRequire } from 'module'; import { fileURLToPath as __fileURLToPath } from 'url'; import { dirname as __dirnameFn } from 'path'; const require = __createRequire(import.meta.url); const __filename = __fileURLToPath(import.meta.url); const __dirname = __dirnameFn(__filename);`,
+  },
+  // Enable tree-shaking to remove unused code
+  treeShaking: true,
+  // Drop console statements in production (but keep for debugging)
+  drop: [],
+});
+
+console.log("✅ Build completed successfully!");
+

fixtures/basic.txt

@@ -1 +1 @@
-create a PR implementing bogosort to https://github.com/pullfrogai/scratch/
+run npx cowsay "don't eat me"

index.ts

@@ -3,8 +3,7 @@
  * This exports the main function for programmatic usage
  */
 
-export { ClaudeAgent } from "./agents/claude.ts";
-export type { Agent, AgentConfig, AgentResult } from "./agents/types.ts";
+export type { Agent, AgentConfig, AgentResult } from "./agents/shared.ts";
 export {
   type Inputs as ExecutionInputs,
   type MainResult,

main.ts

@@ -1,7 +1,12 @@
-import * as core from "@actions/core";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
 import { type } from "arktype";
-import { ClaudeAgent } from "./agents/claude.ts";
-import { setupGitHubInstallationToken } from "./utils/github.ts";
+import { claude } from "./agents/claude.ts";
+import { createMcpConfigs } from "./mcp/config.ts";
+import packageJson from "./package.json" with { type: "json" };
+import { log } from "./utils/cli.ts";
+import { parseRepoContext, setupGitHubInstallationToken } from "./utils/github.ts";
+import { setupGitAuth, setupGitConfig } from "./utils/setup.ts";
 
 export const Inputs = type({
   prompt: "string",
@@ -16,22 +21,74 @@ export interface MainResult {
   error?: string | undefined;
 }
 
+export type PromptJSON = {};
+
+async function printDirectoryTree(dir: string, prefix = "", rootDir = dir): Promise<string> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const lines: string[] = [];
+
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const isLast = i === entries.length - 1;
+    const currentPrefix = isLast ? "└── " : "├── ";
+    const nextPrefix = isLast ? "    " : "│   ";
+
+    const fullPath = join(dir, entry.name);
+    lines.push(`${prefix}${currentPrefix}${entry.name}`);
+
+    if (entry.isDirectory()) {
+      const subTree = await printDirectoryTree(fullPath, `${prefix}${nextPrefix}`, rootDir);
+      lines.push(subTree);
+    }
+  }
+
+  return lines.join("\n");
+}
+
 export async function main(inputs: Inputs): Promise<MainResult> {
   try {
-    core.info(`→ Starting agent run with Claude Code`);
+    // Debug: Print current directory tree before anything runs
+    const cwd = process.cwd();
+    log.info(`Current working directory: ${cwd}`);
+    try {
+      const tree = await printDirectoryTree(cwd);
+      log.info(`Directory tree:\n${tree}`);
+    } catch (error) {
+      log.warning(
+        `Failed to print directory tree: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+
+    log.info(`🐸 Running pullfrog/action@${packageJson.version}...`);
+
+    setupGitConfig();
 
-    // Setup GitHub installation token
     const githubInstallationToken = await setupGitHubInstallationToken();
+    const repoContext = parseRepoContext();
 
-    const agent = new ClaudeAgent({
-      apiKey: inputs.anthropic_api_key!,
+    setupGitAuth(githubInstallationToken, repoContext);
+
+    const mcpServers = createMcpConfigs(githubInstallationToken);
+
+    log.debug(`📋 MCP Config: ${JSON.stringify(mcpServers, null, 2)}`);
+
+    // Install Claude CLI before running
+    await claude.install();
+
+    log.info("Running Claude Agent SDK...");
+    log.box(inputs.prompt, { title: "Prompt" });
+
+    // TODO: check if `inputs.prompts` is JSON
+    // if yes, check if it's a webhook payload or toJSON(github.event)
+    // for webhook payloads, check the specified `agent` field
+
+    const result = await claude.run({
+      prompt: inputs.prompt,
+      mcpServers,
       githubInstallationToken,
+      apiKey: inputs.anthropic_api_key!,
     });
 
-    await agent.install();
-
-    const result = await agent.execute(inputs.prompt);
-
     if (!result.success) {
       return {
         success: false,
@@ -40,12 +97,17 @@ export async function main(inputs: Inputs): Promise<MainResult> {
       };
     }
 
+    log.success("Task complete.");
+    await log.writeSummary();
+
     return {
       success: true,
       output: result.output || "",
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    log.error(errorMessage);
+    await log.writeSummary();
     return {
       success: false,
       error: errorMessage,

mcp/comment.ts

@@ -6,7 +6,7 @@ export const Comment = type({
   body: type.string.describe("the comment body content"),
 });
 
-export const CommentTool = tool({
+export const CreateCommentTool = tool({
   name: "create_issue_comment",
   description: "Create a comment on a GitHub issue",
   parameters: Comment,
@@ -26,3 +26,30 @@ export const CommentTool = tool({
     };
   }),
 });
+
+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 result = await ctx.octokit.rest.issues.updateComment({
+      owner: ctx.owner,
+      repo: ctx.name,
+      comment_id: commentId,
+      body: body,
+    });
+
+    return {
+      success: true,
+      commentId: result.data.id,
+      url: result.data.html_url,
+      body: result.data.body,
+      updatedAt: result.data.updated_at,
+    };
+  }),
+});

mcp/config.ts

@@ -1,35 +1,37 @@
 /**
  * Simple MCP configuration helper for adding our minimal GitHub comment server
  */
-import { fromHere } from "@ark/fs";
 
-const actionPath = fromHere("..");
+import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import { parseRepoContext } from "../utils/github.ts";
 
-export const mcpServerName = "gh-pullfrog";
+export const ghPullfrogMcpName = "gh-pullfrog";
 
-export function createMcpConfig(githubInstallationToken: string) {
-  const githubRepository = process.env.GITHUB_REPOSITORY;
-  if (!githubRepository) {
-    throw new Error(
-      "GITHUB_REPOSITORY environment variable is required for MCP GitHub integration"
-    );
-  }
+export type McpName = typeof ghPullfrogMcpName;
 
-  return JSON.stringify(
-    {
-      mcpServers: {
-        [mcpServerName]: {
-          command: "node",
-          args: [`${actionPath}/mcp/server.ts`],
-          env: {
-            GITHUB_INSTALLATION_TOKEN: githubInstallationToken,
-            GITHUB_REPOSITORY: githubRepository,
-            LOG_LEVEL: "debug",
-          },
-        },
+export type McpConfigs = Record<McpName, McpServerConfig>;
+
+export function createMcpConfigs(githubInstallationToken: string): McpConfigs {
+  const repoContext = parseRepoContext();
+  const githubRepository = `${repoContext.owner}/${repoContext.name}`;
+
+  // Get absolute path to entry.js - use GITHUB_ACTION_PATH if available, otherwise current directory
+  const entryPath = process.env.GITHUB_ACTION_PATH
+    ? `${process.env.GITHUB_ACTION_PATH}/entry.js`
+    : `${process.cwd()}/entry.js`;
+
+  return {
+    [ghPullfrogMcpName]: {
+      command: "node",
+      args: [
+        "--input-type=module",
+        "-e",
+        `import('${entryPath.replace(/'/g, "\\'")}').then(m => m.createMcpServer())`,
+      ],
+      env: {
+        GITHUB_INSTALLATION_TOKEN: githubInstallationToken,
+        GITHUB_REPOSITORY: githubRepository,
       },
     },
-    null,
-    2
-  );
+  };
 }

mcp/pr.ts

@@ -1,5 +1,6 @@
 import { execSync } from "node:child_process";
 import { type } from "arktype";
+import { log } from "../utils/cli.ts";
 import { contextualize, tool } from "./shared.ts";
 
 export const PullRequest = type({
@@ -18,7 +19,7 @@ export const PullRequestTool = tool({
       encoding: "utf8",
     }).trim();
 
-    console.log(`Current branch: ${currentBranch}`);
+    log.info(`Current branch: ${currentBranch}`);
 
     const result = await ctx.octokit.rest.pulls.create({
       owner: ctx.owner,

mcp/prInfo.ts

@@ -0,0 +1,52 @@
+import { execSync } from "node:child_process";
+import { type } from "arktype";
+import { log } from "../utils/cli.ts";
+import { contextualize, 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 and automatically prepare the repository for review by fetching and checking 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,
+    });
+
+    const data = pr.data;
+
+    const baseBranch = data.base.ref;
+    const headBranch = data.head.ref;
+
+    if (!baseBranch) {
+      throw new Error(`Base branch not found for PR #${pull_number}`);
+    }
+
+    // Automatically fetch and checkout branches for review
+    log.info(`Fetching base branch: origin/${baseBranch}`);
+    execSync(`git fetch origin ${baseBranch} --depth=20`, { stdio: "inherit" });
+
+    log.info(`Fetching PR branch: origin/${headBranch}`);
+    execSync(`git fetch origin ${headBranch}`, { stdio: "inherit" });
+
+    log.info(`Checking out PR branch: origin/${headBranch}`);
+    execSync(`git checkout origin/${headBranch}`, { stdio: "inherit" });
+
+    return {
+      number: data.number,
+      url: data.html_url,
+      title: data.title,
+      state: data.state,
+      draft: data.draft,
+      merged: data.merged,
+      base: baseBranch,
+      head: headBranch,
+    };
+  }),
+});

mcp/review.ts

@@ -0,0 +1,94 @@
+import type { RestEndpointMethodTypes } from "@octokit/rest";
+import { type } from "arktype";
+import { contextualize, tool } from "./shared.ts";
+
+export const Review = type({
+  pull_number: type.number.describe("The pull request number to review"),
+  event: type
+    .enumerated("APPROVE", "REQUEST_CHANGES", "COMMENT")
+    .describe("'APPROVE', 'REQUEST_CHANGES', or 'COMMENT' (the review action)"),
+  body: type.string
+    .describe(
+      "Brief summary or general feedback that doesn't apply to specific code locations. Keep it concise - most feedback should be in the 'comments' array."
+    )
+    .optional(),
+  commit_id: type.string
+    .describe("Optional SHA of the commit being reviewed. Defaults to latest.")
+    .optional(),
+  comments: type({
+    path: type.string.describe("The file path to comment on (relative to repo root)"),
+    line: type.number.describe(
+      "The line number in the file (use line numbers from the diff - usually the RIGHT side/new code)"
+    ),
+    side: type
+      .enumerated("LEFT", "RIGHT")
+      .describe(
+        "Side of the diff: LEFT (old code) or RIGHT (new code). Defaults to RIGHT if not provided."
+      )
+      .optional(),
+    body: type.string.describe("The comment text for this specific line"),
+    start_line: type.number
+      .describe("Start line for multi-line comments (optional, for commenting on ranges)")
+      .optional(),
+  })
+    .array()
+    .describe(
+      "REQUIRED: Array of inline comments for specific code issues. Use this for all location-specific feedback. Use 'git diff origin/<base>...origin/<head>' to find the correct line numbers (typically use the line numbers shown on the RIGHT side for new code, LEFT side for old code)."
+    )
+    .optional(),
+});
+
+export const ReviewTool = tool({
+  name: "submit_pull_request_review",
+  description:
+    "Submit a review (approve, request changes, or comment) for an existing pull request. " +
+    "IMPORTANT: Use 'comments' array for ALL specific code issues at the line-level. " +
+    "Only use 'body' for a brief summary or feedback that doesn't apply to a specific location.",
+  parameters: Review,
+  execute: contextualize(async ({ pull_number, event, 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,
+    };
+    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);
+    return {
+      success: true,
+      reviewId: result.data.id,
+      html_url: result.data.html_url,
+      state: result.data.state,
+      user: result.data.user?.login,
+      submitted_at: result.data.submitted_at,
+    };
+  }),
+});

mcp/server.ts

@@ -1,16 +1,27 @@
 #!/usr/bin/env node
 // Minimal GitHub Issue Comment MCP Server
 import { FastMCP } from "fastmcp";
-import { CommentTool } from "./comment.ts";
+import { CreateCommentTool, EditCommentTool } from "./comment.ts";
 import { IssueTool } from "./issue.ts";
 import { PullRequestTool } from "./pr.ts";
+import { PullRequestInfoTool } from "./prInfo.ts";
+import { ReviewTool } from "./review.ts";
 import { addTools } from "./shared.ts";
 
-const server = new FastMCP({
-  name: "gh-pullfrog",
-  version: "0.0.1",
-});
+export function createMcpServer(): void {
+  const server = new FastMCP({
+    name: "gh-pullfrog",
+    version: "0.0.1",
+  });
 
-addTools(server, [CommentTool, IssueTool, PullRequestTool]);
+  addTools(server, [
+    CreateCommentTool,
+    EditCommentTool,
+    IssueTool,
+    PullRequestTool,
+    ReviewTool,
+    PullRequestInfoTool,
+  ]);
 
-server.start();
+  server.start();
+}

mcp/shared.ts

@@ -9,7 +9,6 @@ export interface ToolResult {
     type: "text";
     text: string;
   }[];
-  error?: string;
   isError?: boolean;
 }
 
@@ -72,7 +71,6 @@ const handleToolError = (error: unknown): ToolResult => {
         text: `Error: ${errorMessage}`,
       },
     ],
-    error: errorMessage,
     isError: true,
   };
 };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pullfrog/action",
-  "version": "0.0.54",
+  "version": "0.0.82",
   "type": "module",
   "files": [
     "index.js",
@@ -15,18 +15,21 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "typecheck": "tsc --noEmit",
+    "build": "node esbuild.config.js",
     "play": "node play.ts",
     "upDeps": "pnpm up --latest",
-    "lock": "pnpm --ignore-workspace install"
+    "lock": "pnpm --ignore-workspace install",
+    "prepare": "husky"
   },
   "dependencies": {
     "@actions/core": "^1.11.1",
-    "@ark/fs": "0.50.0",
-    "@ark/util": "0.50.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.1.26",
+    "@ark/fs": "0.53.0",
+    "@ark/util": "0.53.0",
     "@octokit/rest": "^22.0.0",
     "@octokit/webhooks-types": "^7.6.1",
     "@standard-schema/spec": "1.0.0",
-    "arktype": "^2.1.23",
+    "arktype": "2.1.25",
     "dotenv": "^17.2.3",
     "execa": "^9.6.0",
     "fastmcp": "^3.20.0",
@@ -35,6 +38,8 @@
   "devDependencies": {
     "@types/node": "^24.7.2",
     "arg": "^5.0.2",
+    "esbuild": "^0.25.9",
+    "husky": "^9.0.0",
     "typescript": "^5.9.3"
   },
   "repository": {

play.ts

@@ -5,35 +5,25 @@ import { fromHere } from "@ark/fs";
 import arg from "arg";
 import { config } from "dotenv";
 import { type Inputs, main } from "./main.ts";
-import packageJson from "./package.json" with { type: "json" };
-import { runAct } from "./utils/act.ts";
+import { log } from "./utils/cli.ts";
 import { setupTestRepo } from "./utils/setup.ts";
 
 config();
 
 export async function run(
-  prompt: string,
-  options: { act?: boolean } = {}
+  prompt: string
 ): Promise<{ success: boolean; output?: string | undefined; error?: string | undefined }> {
   try {
-    console.log(`🐸 Running pullfrog/action@${packageJson.version}...`);
-    if (options.act) {
-      console.log("🐳 Running with Docker/act...");
-      runAct(prompt);
-      return { success: true };
-    }
-
     const tempDir = join(process.cwd(), ".temp");
     setupTestRepo({ tempDir, forceClean: true });
 
     const originalCwd = process.cwd();
     process.chdir(tempDir);
 
-    console.log("🚀 Running action with prompt...");
-    console.log("─".repeat(50));
-    console.log("Prompt:");
-    console.log(prompt);
-    console.log("─".repeat(50));
+    log.info("🚀 Running action with prompt...");
+    log.separator();
+    log.box(prompt, { title: "Prompt" });
+    log.separator();
 
     const inputs: Inputs = {
       prompt,
@@ -45,18 +35,15 @@ export async function run(
     process.chdir(originalCwd);
 
     if (result.success) {
-      console.log("✅ Action completed successfully");
-      if (result.output) {
-        console.log("Output:", result.output);
-      }
+      log.success("Action completed successfully");
       return { success: true, output: result.output || undefined, error: undefined };
     } else {
-      console.error("❌ Action failed:", result.error);
+      log.error(`Action failed: ${result.error || "Unknown error"}`);
       return { success: false, error: result.error || undefined, output: undefined };
     }
-  } catch (error) {
-    const errorMessage = (error as Error).message;
-    console.error("❌ Error:", errorMessage);
+  } catch (err) {
+    const errorMessage = (err as Error).message;
+    log.error(`Error: ${errorMessage}`);
     return { success: false, error: errorMessage, output: undefined };
   }
 }
@@ -64,13 +51,12 @@ export async function run(
 if (import.meta.url === `file://${process.argv[1]}`) {
   const args = arg({
     "--help": Boolean,
-    "--act": Boolean,
     "--raw": String,
     "-h": "--help",
   });
 
   if (args["--help"]) {
-    console.log(`
+    log.info(`
 Usage: tsx play.ts [file] [options]
 
 Test the Pullfrog action with various prompts.
@@ -79,7 +65,6 @@ Arguments:
   file                    Prompt file to use (.txt, .json, or .ts) [default: fixtures/basic.txt]
 
 Options:
-  --act                   Use Docker/act to run the action instead of running directly
   --raw [prompt]          Use raw string as prompt instead of loading from file
   -h, --help              Show this help message
 
@@ -87,7 +72,7 @@ Examples:
   tsx play.ts                        # Use default fixture
   tsx play.ts fixtures/basic.txt     # Use specific text file
   tsx play.ts custom.json            # Use JSON file
-  tsx play.ts --act fixtures/test.ts # Use TypeScript file with Docker/act
+  tsx play.ts fixtures/test.ts       # Use TypeScript file
   tsx play.ts --raw "Hello world"    # Use raw string as prompt
     `);
     process.exit(0);
@@ -148,13 +133,13 @@ Examples:
   }
 
   try {
-    const result = await run(prompt, { act: args["--act"] || false });
+    const result = await run(prompt);
 
     if (!result.success) {
       process.exit(1);
     }
-  } catch (error) {
-    console.error("❌ Error:", (error as Error).message);
+  } catch (err) {
+    log.error((err as Error).message);
     process.exit(1);
   }
 }

pnpm-lock.yaml

@@ -11,12 +11,15 @@ importers:
       '@actions/core':
         specifier: ^1.11.1
         version: 1.11.1
+      '@anthropic-ai/claude-agent-sdk':
+        specifier: ^0.1.26
+        version: 0.1.30(zod@3.25.76)
       '@ark/fs':
-        specifier: 0.50.0
-        version: 0.50.0
+        specifier: 0.53.0
+        version: 0.53.0
       '@ark/util':
-        specifier: 0.50.0
-        version: 0.50.0
+        specifier: 0.53.0
+        version: 0.53.0
       '@octokit/rest':
         specifier: ^22.0.0
         version: 22.0.0
@@ -27,8 +30,8 @@ importers:
         specifier: 1.0.0
         version: 1.0.0
       arktype:
-        specifier: ^2.1.23
-        version: 2.1.23
+        specifier: 2.1.25
+        version: 2.1.25
       dotenv:
         specifier: ^17.2.3
         version: 17.2.3
@@ -37,7 +40,7 @@ importers:
         version: 9.6.0
       fastmcp:
         specifier: ^3.20.0
-        version: 3.20.0(arktype@2.1.23)
+        version: 3.20.0(arktype@2.1.25)
       table:
         specifier: ^6.9.0
         version: 6.9.0
@@ -48,6 +51,12 @@ importers:
       arg:
         specifier: ^5.0.2
         version: 5.0.2
+      esbuild:
+        specifier: ^0.25.9
+        version: 0.25.12
+      husky:
+        specifier: ^9.0.0
+        version: 9.1.7
       typescript:
         specifier: ^5.9.3
         version: 5.9.3
@@ -66,25 +75,245 @@ packages:
   '@actions/io@1.1.3':
     resolution: {integrity: sha512-wi9JjgKLYS7U/z8PPbco+PvTb/nRWjeoFlJ1Qer83k/3C5PHQi28hiVdeE2kHXmIL99mQFawx8qt/JPjZilJ8Q==}
 
-  '@ark/fs@0.50.0':
-    resolution: {integrity: sha512-6OrxNt2T+/pL4RUMZK/aiVRLIS3acNs5uSpHDyZAP6+OXwXchFSQ1lJTH+uuGBlDWeQxPD7VmymYXLF5s1Eyhw==}
+  '@anthropic-ai/claude-agent-sdk@0.1.30':
+    resolution: {integrity: sha512-lo1tqxCr2vygagFp6kUMHKSN6AAWlULCskwGKtLB/JcIXy/8H8GsLSKX54anTsvc9mBbCR8wWASdFmiiL9NSKA==}
+    engines: {node: '>=18.0.0'}
+    peerDependencies:
+      zod: ^3.24.1
 
-  '@ark/regex@0.0.0':
-    resolution: {integrity: sha512-p4vsWnd/LRGOdGQglbwOguIVhPmCAf5UzquvnDoxqhhPWTP84wWgi1INea8MgJ4SnI2gp37f13oA4Waz9vwNYg==}
+  '@ark/fs@0.53.0':
+    resolution: {integrity: sha512-XL0EbBAZgyy+j9aPhftYaBsbKAW5PTNSKCN6oLRRdrHuHPSAZgR6765/z0YZGhPxHEUNmq0vBoSk8yOLk91dNQ==}
 
-  '@ark/schema@0.50.0':
-    resolution: {integrity: sha512-hfmP82GltBZDadIOeR3argKNlYYyB2wyzHp0eeAqAOFBQguglMV/S7Ip2q007bRtKxIMLDqFY6tfPie1dtssaQ==}
+  '@ark/schema@0.53.0':
+    resolution: {integrity: sha512-1PB7RThUiTlmIu8jbSurPrhHpVixPd4C+xNBUF/HrjIENCeDcAMg36n5mpMzED7OQGDVIzpfXXiMnaTiutjHJw==}
 
-  '@ark/util@0.50.0':
-    resolution: {integrity: sha512-tIkgIMVRpkfXRQIEf0G2CJryZVtHVrqcWHMDa5QKo0OEEBu0tHkRSIMm4Ln8cd8Bn9TPZtvc/kE2Gma8RESPSg==}
+  '@ark/util@0.53.0':
+    resolution: {integrity: sha512-TGn4gLlA6dJcQiqrtCtd88JhGb2XBHo6qIejsDre+nxpGuUVW4G3YZGVrwjNBTO0EyR+ykzIo4joHJzOj+/cpA==}
 
   '@borewit/text-codec@0.1.1':
     resolution: {integrity: sha512-5L/uBxmjaCIX5h8Z+uu+kA9BQLkc/Wl06UGR5ajNRxu+/XjonB5i8JpgFMrPj3LXTCPA0pv8yxUvbUi+QthGGA==}
 
+  '@esbuild/aix-ppc64@0.25.12':
+    resolution: {integrity: sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.25.12':
+    resolution: {integrity: sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.25.12':
+    resolution: {integrity: sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.25.12':
+    resolution: {integrity: sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.25.12':
+    resolution: {integrity: sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.25.12':
+    resolution: {integrity: sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.25.12':
+    resolution: {integrity: sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.25.12':
+    resolution: {integrity: sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.25.12':
+    resolution: {integrity: sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.25.12':
+    resolution: {integrity: sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.25.12':
+    resolution: {integrity: sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.25.12':
+    resolution: {integrity: sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.25.12':
+    resolution: {integrity: sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.25.12':
+    resolution: {integrity: sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.25.12':
+    resolution: {integrity: sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.25.12':
+    resolution: {integrity: sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.25.12':
+    resolution: {integrity: sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.25.12':
+    resolution: {integrity: sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.25.12':
+    resolution: {integrity: sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.25.12':
+    resolution: {integrity: sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.25.12':
+    resolution: {integrity: sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.25.12':
+    resolution: {integrity: sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.25.12':
+    resolution: {integrity: sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.25.12':
+    resolution: {integrity: sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.25.12':
+    resolution: {integrity: sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.25.12':
+    resolution: {integrity: sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
   '@fastify/busboy@2.1.1':
     resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==}
     engines: {node: '>=14'}
 
+  '@img/sharp-darwin-arm64@0.33.5':
+    resolution: {integrity: sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.33.5':
+    resolution: {integrity: sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-arm64@1.0.4':
+    resolution: {integrity: sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.0.4':
+    resolution: {integrity: sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-linux-arm64@1.0.4':
+    resolution: {integrity: sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-arm@1.0.5':
+    resolution: {integrity: sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-x64@1.0.4':
+    resolution: {integrity: sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linux-arm64@0.33.5':
+    resolution: {integrity: sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linux-arm@0.33.5':
+    resolution: {integrity: sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-linux-x64@0.33.5':
+    resolution: {integrity: sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-win32-x64@0.33.5':
+    resolution: {integrity: sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [win32]
+
   '@modelcontextprotocol/sdk@1.20.0':
     resolution: {integrity: sha512-kOQ4+fHuT4KbR2iq2IjeV32HiihueuOf1vJkq18z08CLZ1UQrTc8BXJpVfxZkq45+inLLD+D4xx4nBjUelJa4Q==}
     engines: {node: '>=18'}
@@ -193,8 +422,11 @@ packages:
   arg@5.0.2:
     resolution: {integrity: sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==}
 
-  arktype@2.1.23:
-    resolution: {integrity: sha512-tyxNWX6xJVMb2EPJJ3OjgQS1G/vIeQRrZuY4DeBNQmh8n7geS+czgbauQWB6Pr+RXiOO8ChEey44XdmxsqGmfQ==}
+  arkregex@0.0.2:
+    resolution: {integrity: sha512-ttjDUICBVoXD/m8bf7eOjx8XMR6yIT2FmmW9vsN0FCcFOygEZvvIX8zK98tTdXkzi0LkRi5CmadB44jFEIyDNA==}
+
+  arktype@2.1.25:
+    resolution: {integrity: sha512-fdj10sNlUPeDRg1QUqMbzJ4Q7gutTOWOpLUNdcC4vxeVrN0G+cbDOvLbuxQOFj/NDAode1G7kwFv4yKwQvupJg==}
 
   astral-regex@2.0.0:
     resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==}
@@ -300,6 +532,11 @@ packages:
     resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
     engines: {node: '>= 0.4'}
 
+  esbuild@0.25.12:
+    resolution: {integrity: sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   escalade@3.2.0:
     resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
     engines: {node: '>=6'}
@@ -419,6 +656,11 @@ packages:
     resolution: {integrity: sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==}
     engines: {node: '>=18.18.0'}
 
+  husky@9.1.7:
+    resolution: {integrity: sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   iconv-lite@0.6.3:
     resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
     engines: {node: '>=0.10.0'}
@@ -795,22 +1037,150 @@ snapshots:
 
   '@actions/io@1.1.3': {}
 
-  '@ark/fs@0.50.0': {}
-
-  '@ark/regex@0.0.0':
+  '@anthropic-ai/claude-agent-sdk@0.1.30(zod@3.25.76)':
     dependencies:
-      '@ark/util': 0.50.0
+      zod: 3.25.76
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.33.5
+      '@img/sharp-darwin-x64': 0.33.5
+      '@img/sharp-linux-arm': 0.33.5
+      '@img/sharp-linux-arm64': 0.33.5
+      '@img/sharp-linux-x64': 0.33.5
+      '@img/sharp-win32-x64': 0.33.5
 
-  '@ark/schema@0.50.0':
+  '@ark/fs@0.53.0': {}
+
+  '@ark/schema@0.53.0':
     dependencies:
-      '@ark/util': 0.50.0
+      '@ark/util': 0.53.0
 
-  '@ark/util@0.50.0': {}
+  '@ark/util@0.53.0': {}
 
   '@borewit/text-codec@0.1.1': {}
 
+  '@esbuild/aix-ppc64@0.25.12':
+    optional: true
+
+  '@esbuild/android-arm64@0.25.12':
+    optional: true
+
+  '@esbuild/android-arm@0.25.12':
+    optional: true
+
+  '@esbuild/android-x64@0.25.12':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.25.12':
+    optional: true
+
+  '@esbuild/darwin-x64@0.25.12':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.25.12':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.25.12':
+    optional: true
+
+  '@esbuild/linux-arm64@0.25.12':
+    optional: true
+
+  '@esbuild/linux-arm@0.25.12':
+    optional: true
+
+  '@esbuild/linux-ia32@0.25.12':
+    optional: true
+
+  '@esbuild/linux-loong64@0.25.12':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.25.12':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.25.12':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.25.12':
+    optional: true
+
+  '@esbuild/linux-s390x@0.25.12':
+    optional: true
+
+  '@esbuild/linux-x64@0.25.12':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.25.12':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.25.12':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.25.12':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.25.12':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.25.12':
+    optional: true
+
+  '@esbuild/sunos-x64@0.25.12':
+    optional: true
+
+  '@esbuild/win32-arm64@0.25.12':
+    optional: true
+
+  '@esbuild/win32-ia32@0.25.12':
+    optional: true
+
+  '@esbuild/win32-x64@0.25.12':
+    optional: true
+
   '@fastify/busboy@2.1.1': {}
 
+  '@img/sharp-darwin-arm64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.0.4
+    optional: true
+
+  '@img/sharp-darwin-x64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.0.4
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.0.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.0.5':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.0.4':
+    optional: true
+
+  '@img/sharp-linux-arm64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.0.4
+    optional: true
+
+  '@img/sharp-linux-arm@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.0.5
+    optional: true
+
+  '@img/sharp-linux-x64@0.33.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.0.4
+    optional: true
+
+  '@img/sharp-win32-x64@0.33.5':
+    optional: true
+
   '@modelcontextprotocol/sdk@1.20.0':
     dependencies:
       ajv: 6.12.6
@@ -943,11 +1313,15 @@ snapshots:
 
   arg@5.0.2: {}
 
-  arktype@2.1.23:
+  arkregex@0.0.2:
     dependencies:
-      '@ark/regex': 0.0.0
-      '@ark/schema': 0.50.0
-      '@ark/util': 0.50.0
+      '@ark/util': 0.53.0
+
+  arktype@2.1.25:
+    dependencies:
+      '@ark/schema': 0.53.0
+      '@ark/util': 0.53.0
+      arkregex: 0.0.2
 
   astral-regex@2.0.0: {}
 
@@ -1042,6 +1416,35 @@ snapshots:
     dependencies:
       es-errors: 1.3.0
 
+  esbuild@0.25.12:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.25.12
+      '@esbuild/android-arm': 0.25.12
+      '@esbuild/android-arm64': 0.25.12
+      '@esbuild/android-x64': 0.25.12
+      '@esbuild/darwin-arm64': 0.25.12
+      '@esbuild/darwin-x64': 0.25.12
+      '@esbuild/freebsd-arm64': 0.25.12
+      '@esbuild/freebsd-x64': 0.25.12
+      '@esbuild/linux-arm': 0.25.12
+      '@esbuild/linux-arm64': 0.25.12
+      '@esbuild/linux-ia32': 0.25.12
+      '@esbuild/linux-loong64': 0.25.12
+      '@esbuild/linux-mips64el': 0.25.12
+      '@esbuild/linux-ppc64': 0.25.12
+      '@esbuild/linux-riscv64': 0.25.12
+      '@esbuild/linux-s390x': 0.25.12
+      '@esbuild/linux-x64': 0.25.12
+      '@esbuild/netbsd-arm64': 0.25.12
+      '@esbuild/netbsd-x64': 0.25.12
+      '@esbuild/openbsd-arm64': 0.25.12
+      '@esbuild/openbsd-x64': 0.25.12
+      '@esbuild/openharmony-arm64': 0.25.12
+      '@esbuild/sunos-x64': 0.25.12
+      '@esbuild/win32-arm64': 0.25.12
+      '@esbuild/win32-ia32': 0.25.12
+      '@esbuild/win32-x64': 0.25.12
+
   escalade@3.2.0: {}
 
   escape-html@1.0.3: {}
@@ -1113,7 +1516,7 @@ snapshots:
 
   fast-uri@3.1.0: {}
 
-  fastmcp@3.20.0(arktype@2.1.23):
+  fastmcp@3.20.0(arktype@2.1.25):
     dependencies:
       '@modelcontextprotocol/sdk': 1.20.0
       '@standard-schema/spec': 1.0.0
@@ -1124,7 +1527,7 @@ snapshots:
       strict-event-emitter-types: 2.0.0
       undici: 7.16.0
       uri-templates: 0.2.0
-      xsschema: 0.3.5(arktype@2.1.23)(zod-to-json-schema@3.24.6(zod@3.25.76))(zod@3.25.76)
+      xsschema: 0.3.5(arktype@2.1.25)(zod-to-json-schema@3.24.6(zod@3.25.76))(zod@3.25.76)
       yargs: 18.0.0
       zod: 3.25.76
       zod-to-json-schema: 3.24.6(zod@3.25.76)
@@ -1214,6 +1617,8 @@ snapshots:
 
   human-signals@8.0.1: {}
 
+  husky@9.1.7: {}
+
   iconv-lite@0.6.3:
     dependencies:
       safer-buffer: 2.1.2
@@ -1496,9 +1901,9 @@ snapshots:
 
   wrappy@1.0.2: {}
 
-  xsschema@0.3.5(arktype@2.1.23)(zod-to-json-schema@3.24.6(zod@3.25.76))(zod@3.25.76):
+  xsschema@0.3.5(arktype@2.1.25)(zod-to-json-schema@3.24.6(zod@3.25.76))(zod@3.25.76):
     optionalDependencies:
-      arktype: 2.1.23
+      arktype: 2.1.25
       zod: 3.25.76
       zod-to-json-schema: 3.24.6(zod@3.25.76)
 

todo.md

@@ -0,0 +1,8 @@
+[x] add modes to prompt 
+[x] progressively update comment
+[] don't allow rejecting prs
+[] fix pnpm caching
+[] try to avoid claude narrating the initial comment
+[] fix prompt to avoid narration like "I just read all tools from MCP server"
+[] investigate including terminal output from bash commands as collapsed groups
+[] avoid exposing env

utils/act.ts

@@ -1,76 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { config } from "dotenv";
-import { buildAction, setupTestRepo } from "./setup.ts";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const tempDir = join(__dirname, "..", ".temp");
-const actionPath = join(__dirname, "..");
-const envPath = join(__dirname, "..", "..", ".env");
-
-const ENV_VARS = ["ANTHROPIC_API_KEY", "GITHUB_INSTALLATION_TOKEN"];
-
-export function runAct(prompt: string): void {
-  setupTestRepo({ tempDir });
-
-  config({ path: envPath });
-
-  buildAction(actionPath);
-
-  const workflowPath = join(tempDir, ".github", "workflows", "pullfrog.yml");
-
-  const distPath = join(actionPath, ".act-dist");
-  console.log("📦 Creating minimal distribution for act...");
-  execSync(`rm -rf "${distPath}" && mkdir -p "${distPath}"`, { shell: "/bin/bash" });
-
-  ["action.yml", "entry.cjs", "index.cjs", "package.json"].forEach((file) => {
-    const src = join(actionPath, file);
-    if (existsSync(src)) {
-      execSync(`cp "${src}" "${distPath}"`);
-    }
-  });
-
-  try {
-    const escapedPrompt = prompt.replace(/'/g, "'\\''");
-
-    const actCommandParts = [
-      "act",
-      "workflow_dispatch",
-      "-W",
-      workflowPath,
-      "--input",
-      `prompt='${escapedPrompt}'`,
-      "--local-repository",
-      `pullfrog/action@v0=${distPath}`, // Use minimal dist without symlinks
-    ];
-
-    ENV_VARS.forEach((key) => {
-      if (process.env[key]) {
-        actCommandParts.push("-s", key);
-      }
-    });
-
-
-    const actCommand = actCommandParts.join(" ");
-
-    console.log("🚀 Running act with prompt:");
-    console.log("─".repeat(50));
-    console.log(prompt);
-    console.log("─".repeat(50));
-    console.log("");
-
-    execSync(actCommand, {
-      stdio: "inherit",
-      cwd: join(__dirname, "..", ".."),
-    });
-    execSync(`rm -rf "${distPath}"`);
-  } catch (error) {
-    execSync(`rm -rf "${distPath}"`);
-    console.error("❌ Act execution failed:", (error as Error).message);
-    process.exit(1);
-  }
-}

utils/cli.ts

@@ -0,0 +1,264 @@
+/**
+ * CLI output utilities that work well in both local and GitHub Actions environments
+ */
+
+import * as core from "@actions/core";
+
+const isGitHubActions = !!process.env.GITHUB_ACTIONS;
+const isDebugEnabled = process.env.LOG_LEVEL === "debug";
+
+/**
+ * Start a collapsed group (GitHub Actions) or regular group (local)
+ */
+function startGroup(name: string): void {
+  if (isGitHubActions) {
+    core.startGroup(name);
+  } else {
+    console.group(name);
+  }
+}
+
+/**
+ * End a collapsed group
+ */
+function endGroup(): void {
+  if (isGitHubActions) {
+    core.endGroup();
+  } else {
+    console.groupEnd();
+  }
+}
+
+/**
+ * Print a formatted box with text (for console output)
+ */
+function boxString(
+  text: string,
+  options?: {
+    title?: string;
+    maxWidth?: number;
+    indent?: string;
+    padding?: number;
+  }
+): string {
+  const { title, maxWidth = 80, indent = "", padding = 1 } = options || {};
+
+  const lines = text.trim().split("\n");
+  const wrappedLines: string[] = [];
+
+  for (const line of lines) {
+    if (line.length <= maxWidth - padding * 2) {
+      wrappedLines.push(line);
+    } else {
+      const words = line.split(" ");
+      let currentLine = "";
+
+      for (const word of words) {
+        const testLine = currentLine ? `${currentLine} ${word}` : word;
+        if (testLine.length <= maxWidth - padding * 2) {
+          currentLine = testLine;
+        } else {
+          if (currentLine) {
+            wrappedLines.push(currentLine);
+            currentLine = word;
+          } else {
+            wrappedLines.push(word.substring(0, maxWidth - padding * 2));
+            currentLine = word.substring(maxWidth - padding * 2);
+          }
+        }
+      }
+
+      if (currentLine) {
+        wrappedLines.push(currentLine);
+      }
+    }
+  }
+
+  const maxLineLength = Math.max(...wrappedLines.map((line) => line.length));
+  const boxWidth = maxLineLength + padding * 2;
+
+  let result = "";
+
+  if (title) {
+    const titleLine = ` ${title} `;
+    const titlePadding = Math.max(0, boxWidth - titleLine.length);
+    result += `${indent}┌${titleLine}${"─".repeat(titlePadding)}┐\n`;
+  }
+
+  if (!title) {
+    result += `${indent}┌${"─".repeat(boxWidth)}┐\n`;
+  }
+
+  for (const line of wrappedLines) {
+    const paddedLine = line.padEnd(maxLineLength);
+    result += `${indent}│${" ".repeat(padding)}${paddedLine}${" ".repeat(padding)}│\n`;
+  }
+
+  result += `${indent}└${"─".repeat(boxWidth)}┘`;
+
+  return result;
+}
+
+/**
+ * Print a formatted box with text
+ * Works well in both local and GitHub Actions environments
+ */
+function box(
+  text: string,
+  options?: {
+    title?: string;
+    maxWidth?: number;
+  }
+): void {
+  const boxContent = boxString(text, options);
+  core.info(boxContent);
+  if (isGitHubActions) {
+    // Add as markdown code block for summary (no headers)
+    core.summary.addRaw(`\`\`\`\n${text}\n\`\`\`\n`);
+  }
+}
+
+/**
+ * Add a table to GitHub Actions job summary (rich formatting)
+ * Also logs to console. Only use this once at the end of execution.
+ */
+async function summaryTable(
+  rows: Array<Array<{ data: string; header?: boolean } | string>>,
+  options?: {
+    title?: string;
+  }
+): Promise<void> {
+  const { title } = options || {};
+
+  // Convert rows to format expected by Job Summaries API
+  const formattedRows = rows.map((row) =>
+    row.map((cell) => {
+      if (typeof cell === "string") {
+        return { data: cell };
+      }
+      return cell;
+    })
+  );
+
+  if (isGitHubActions) {
+    const summary = core.summary;
+    if (title) {
+      summary.addRaw(`**${title}**\n\n`);
+    }
+    summary.addTable(formattedRows);
+    // Note: Don't write immediately, let it accumulate with other summary content
+  }
+
+  // Also log to console for visibility
+  if (title) {
+    core.info(`\n${title}`);
+  }
+  const tableText = formattedRows.map((row) => row.map((cell) => cell.data).join(" | ")).join("\n");
+  core.info(`\n${tableText}\n`);
+}
+
+/**
+ * Print a separator line
+ */
+function separator(length: number = 50): void {
+  const separatorText = "─".repeat(length);
+  core.info(separatorText);
+  if (isGitHubActions) {
+    core.summary.addRaw(`---\n`);
+  }
+}
+
+/**
+ * Main logging utility object - import this once and access all utilities
+ */
+export const log = {
+  /**
+   * Print info message
+   */
+  info: (message: string): void => {
+    core.info(message);
+    if (isGitHubActions) {
+      core.summary.addRaw(`${message}\n`);
+    }
+  },
+
+  /**
+   * Print warning message
+   */
+  warning: (message: string): void => {
+    core.warning(message);
+    if (isGitHubActions) {
+      core.summary.addRaw(`⚠️ ${message}\n`);
+    }
+  },
+
+  /**
+   * Print error message
+   */
+  error: (message: string): void => {
+    core.error(message);
+    if (isGitHubActions) {
+      core.summary.addRaw(`❌ ${message}\n`);
+    }
+  },
+
+  /**
+   * Print success message
+   */
+  success: (message: string): void => {
+    const successMessage = `✅ ${message}`;
+    core.info(successMessage);
+    if (isGitHubActions) {
+      core.summary.addRaw(`${successMessage}\n`);
+    }
+  },
+
+  /**
+   * Print debug message (only if LOG_LEVEL=debug)
+   */
+  debug: (message: string): void => {
+    if (isDebugEnabled) {
+      if (isGitHubActions) {
+        core.debug(message);
+      } else {
+        core.info(`[DEBUG] ${message}`);
+      }
+    }
+  },
+
+  /**
+   * Print a formatted box with text
+   */
+  box,
+
+  /**
+   * Add a table to GitHub Actions job summary (rich formatting)
+   * Only use this once at the end of execution
+   */
+  summaryTable,
+
+  /**
+   * Print a separator line
+   */
+  separator,
+
+  /**
+   * Write all accumulated summary content to the job summary
+   * Call this at the end of execution to finalize the summary
+   */
+  writeSummary: async (): Promise<void> => {
+    if (isGitHubActions) {
+      await core.summary.write();
+    }
+  },
+
+  /**
+   * Start a collapsed group (GitHub Actions) or regular group (local)
+   */
+  startGroup,
+
+  /**
+   * End a collapsed group
+   */
+  endGroup,
+};

utils/files.ts

@@ -1,13 +0,0 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-/**
- * Create a temporary file with the given content
- */
-export function createTempFile(content: string, filename = "temp.txt"): string {
-  const tempDir = mkdtempSync(join(tmpdir(), "pullfrog-"));
-  const filePath = join(tempDir, filename);
-  writeFileSync(filePath, content);
-  return filePath;
-}

utils/github.ts

@@ -1,5 +1,6 @@
 import { createSign } from "node:crypto";
 import * as core from "@actions/core";
+import { log } from "./cli.ts";
 
 export interface InstallationToken {
   token: string;
@@ -53,14 +54,14 @@ function isGitHubActionsEnvironment(): boolean {
 }
 
 async function acquireTokenViaOIDC(): Promise<string> {
-  core.info("Generating OIDC token...");
+  log.info("Generating OIDC token...");
 
   const oidcToken = await core.getIDToken("pullfrog-api");
-  core.info("OIDC token generated successfully");
+  log.info("OIDC token generated successfully");
 
   const apiUrl = process.env.API_URL || "https://pullfrog.ai";
 
-  core.info("Exchanging OIDC token for installation token...");
+  log.info("Exchanging OIDC token for installation token...");
   const tokenResponse = await fetch(`${apiUrl}/api/github/installation-token`, {
     method: "POST",
     headers: {
@@ -77,7 +78,7 @@ async function acquireTokenViaOIDC(): Promise<string> {
   }
 
   const tokenData = (await tokenResponse.json()) as InstallationToken;
-  core.info(`Installation token obtained for ${tokenData.repository || "all repositories"}`);
+  log.info(`Installation token obtained for ${tokenData.repository || "all repositories"}`);
 
   return tokenData.token;
 }
@@ -238,7 +239,7 @@ export async function setupGitHubInstallationToken(): Promise<string> {
   const existingToken = checkExistingToken();
   if (existingToken) {
     core.setSecret(existingToken);
-    core.info("Using provided GitHub installation token");
+    log.info("Using provided GitHub installation token");
     return existingToken;
   }
 

utils/setup.ts

@@ -1,5 +1,7 @@
 import { execSync } from "node:child_process";
 import { existsSync, rmSync } from "node:fs";
+import { log } from "./cli.ts";
+import type { RepoContext } from "./github.ts";
 
 export interface SetupOptions {
   tempDir: string;
@@ -19,31 +21,72 @@ export function setupTestRepo(options: SetupOptions): void {
 
   if (existsSync(tempDir)) {
     if (forceClean) {
-      console.log("🗑️  Removing existing .temp directory...");
+      log.info("🗑️  Removing existing .temp directory...");
       rmSync(tempDir, { recursive: true, force: true });
 
-      console.log("📦 Cloning pullfrogai/scratch into .temp...");
+      log.info("📦 Cloning pullfrogai/scratch into .temp...");
       execSync(`git clone ${repoUrl} ${tempDir}`, { stdio: "inherit" });
     } else {
-      console.log("📦 Resetting existing .temp repository...");
+      log.info("📦 Resetting existing .temp repository...");
       execSync("git reset --hard HEAD && git clean -fd", {
         cwd: tempDir,
         stdio: "inherit",
       });
     }
   } else {
-    console.log("📦 Cloning pullfrogai/scratch into .temp...");
+    log.info("📦 Cloning pullfrogai/scratch into .temp...");
     execSync(`git clone ${repoUrl} ${tempDir}`, { stdio: "inherit" });
   }
 }
 
 /**
- * Build the action bundles
+ * Setup git configuration to avoid identity errors
+ * Only runs in GitHub Actions environment to avoid overwriting local git config
  */
-export function buildAction(actionPath: string): void {
-  console.log("🔨 Building fresh bundles with esbuild...");
-  execSync("node esbuild.config.js", {
-    cwd: actionPath,
-    stdio: "inherit",
-  });
+export function setupGitConfig(): void {
+  // Only set up git config in GitHub Actions environment
+  // In local development, use the user's existing git config
+  if (!process.env.GITHUB_ACTIONS) {
+    return;
+  }
+
+  log.info("🔧 Setting up git configuration...");
+  try {
+    execSync('git config user.email "action@pullfrog.ai"', { stdio: "pipe" });
+    execSync('git config user.name "Pullfrog Action"', { stdio: "pipe" });
+    log.debug("setupGitConfig: ✓ Git configuration set successfully");
+  } catch (error) {
+    // If git config fails, log warning but don't fail the action
+    // This can happen if we're not in a git repo or git isn't available
+    log.warning(
+      `Failed to set git config: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+/**
+ * Setup git authentication using GitHub token
+ * Only runs in GitHub Actions environment to avoid breaking local git remotes
+ */
+export function setupGitAuth(githubToken: string, repoContext: RepoContext): void {
+  // Only set up git auth in GitHub Actions environment
+  // In local testing, this would overwrite the real git remote with fake credentials
+  if (!process.env.GITHUB_ACTIONS) {
+    return;
+  }
+
+  log.info("🔐 Setting up git authentication...");
+
+  // Remove existing git auth headers that actions/checkout might have set
+  try {
+    execSync("git config --unset-all http.https://github.com/.extraheader", { stdio: "inherit" });
+    log.info("✓ Removed existing authentication headers");
+  } catch {
+    log.info("No existing authentication headers to remove");
+  }
+
+  // Update remote URL to embed the token
+  const remoteUrl = `https://x-access-token:${githubToken}@github.com/${repoContext.owner}/${repoContext.name}.git`;
+  execSync(`git remote set-url origin "${remoteUrl}"`, { stdio: "inherit" });
+  log.info("✓ Updated remote URL with authentication token");
 }

utils/subprocess.ts

@@ -6,6 +6,7 @@ export interface SpawnOptions {
   env?: Record<string, string>;
   input?: string;
   timeout?: number;
+  cwd?: string;
   onStdout?: (chunk: string) => void;
   onStderr?: (chunk: string) => void;
 }
@@ -21,7 +22,7 @@ export interface SpawnResult {
  * Spawn a subprocess with streaming callbacks and buffered results
  */
 export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
-  const { cmd, args, env, input, timeout, onStdout, onStderr } = options;
+  const { cmd, args, env, input, timeout, cwd, onStdout, onStderr } = options;
 
   const startTime = Date.now();
   let stdoutBuffer = "";
@@ -31,6 +32,7 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
     const child = nodeSpawn(cmd, args, {
       env: env ? { ...process.env, ...env } : process.env,
       stdio: ["pipe", "pipe", "pipe"],
+      cwd: cwd || process.cwd(),
     });
 
     let timeoutId: NodeJS.Timeout | undefined;

utils/table.ts

@@ -1,142 +0,0 @@
-import { table } from "table";
-
-/**
- * Print a formatted table with consistent styling
- * @param rows - Array of string arrays representing table rows
- * @param options - Optional table configuration
- */
-
-export function tableString(
-  rows: string[][],
-  options?: {
-    title?: string;
-    indent?: string;
-    drawHorizontalLine?: (lineIndex: number, rowCount: number) => boolean;
-  }
-): string {
-  const {
-    title,
-    indent = "",
-    drawHorizontalLine = (lineIndex: number, rowCount: number) => {
-      return lineIndex === 0 || (options?.title && lineIndex === 1) || lineIndex === rowCount;
-    },
-  } = options || {};
-
-  if (title) {
-    rows.unshift([title]);
-  }
-
-  const tableOutput = table(rows, {
-    drawHorizontalLine,
-    border: {
-      topBody: `─`,
-      topJoin: `┬`,
-      topLeft: `┌`,
-      topRight: `┐`,
-
-      bottomBody: `─`,
-      bottomJoin: `┴`,
-      bottomLeft: `└`,
-      bottomRight: `┘`,
-
-      bodyLeft: `│`,
-      bodyRight: `│`,
-      bodyJoin: `│`,
-
-      joinBody: `─`,
-      joinLeft: `├`,
-      joinRight: `┤`,
-      joinJoin: `┼`,
-    },
-  });
-
-  const indentedOutput = tableOutput.split("\n").join(`\n${indent}`).trim();
-
-  return `${indent}${indentedOutput}`;
-}
-
-/**
- * Print a multi-line string in a formatted box with text wrapping
- * @param text - The text to display
- * @param options - Optional configuration for the box
- */
-export function boxString(
-  text: string,
-  options?: {
-    title?: string;
-    maxWidth?: number;
-    indent?: string;
-    padding?: number;
-  }
-): string {
-  const { title, maxWidth = 80, indent = "", padding = 1 } = options || {};
-
-  // Clean up the text and split into lines
-  const lines = text.trim().split("\n");
-
-  // Word wrap each line to fit within maxWidth
-  const wrappedLines: string[] = [];
-  for (const line of lines) {
-    if (line.length <= maxWidth - padding * 2) {
-      wrappedLines.push(line);
-    } else {
-      // Word wrap the line
-      const words = line.split(" ");
-      let currentLine = "";
-
-      for (const word of words) {
-        const testLine = currentLine ? `${currentLine} ${word}` : word;
-        if (testLine.length <= maxWidth - padding * 2) {
-          currentLine = testLine;
-        } else {
-          if (currentLine) {
-            wrappedLines.push(currentLine);
-            currentLine = word;
-          } else {
-            // Word is too long, break it
-            wrappedLines.push(word.substring(0, maxWidth - padding * 2));
-            currentLine = word.substring(maxWidth - padding * 2);
-          }
-        }
-      }
-
-      if (currentLine) {
-        wrappedLines.push(currentLine);
-      }
-    }
-  }
-
-  // Find the maximum line length for box sizing
-  const maxLineLength = Math.max(...wrappedLines.map((line) => line.length));
-  const boxWidth = maxLineLength + padding * 2;
-
-  // Create the box
-  const topBorder = "┌" + "─".repeat(boxWidth) + "┐";
-  const bottomBorder = "└" + "─".repeat(boxWidth) + "┘";
-  const sideBorder = "│";
-
-  let result = "";
-
-  // Add title if provided
-  if (title) {
-    const titleLine = ` ${title} `;
-    const titlePadding = Math.max(0, boxWidth - titleLine.length);
-    result += `${indent}┌${titleLine}${"─".repeat(titlePadding)}┐\n`;
-  }
-
-  // Add top border (or title border)
-  if (!title) {
-    result += `${indent}${topBorder}\n`;
-  }
-
-  // Add content lines
-  for (const line of wrappedLines) {
-    const paddedLine = line.padEnd(maxLineLength);
-    result += `${indent}${sideBorder}${" ".repeat(padding)}${paddedLine}${" ".repeat(padding)}${sideBorder}\n`;
-  }
-
-  // Add bottom border
-  result += `${indent}${bottomBorder}`;
-
-  return result;
-}