fix: update tool-call extraction logic for Pi session JSONL

Refine parsing of assistant tool calls in review.sh to handle "toolCall" and "arguments" structures, aligning with Pi session format changes.

action.yml

@@ -18,6 +18,10 @@ inputs:
     description: "Custom API base URL (for OpenAI-compatible providers). Ignored for built-in providers."
     required: false
     default: ""
+  server_url:
+    description: "Override the Gitea/GitHub server URL used for API calls (e.g. http://server:3000 for internal routing inside the runner). Defaults to the auto-detected server URL."
+    required: false
+    default: ""
   token:
     description: "Git platform token for posting PR comments"
     required: true

entrypoint.sh

@@ -11,6 +11,7 @@ export PI_API_KEY="${INPUT_API_KEY}"
 export PI_PROVIDER="${INPUT_PROVIDER:-zai}"
 export PI_MODEL="${INPUT_MODEL:-glm-5.1}"
 export PI_BASE_URL="${INPUT_BASE_URL:-}"
+export PI_SERVER_URL="${INPUT_SERVER_URL:-}"
 export PI_TOOLS="${INPUT_TOOLS:-read,grep,find,ls}"
 export PI_REVIEW_PROMPT="${INPUT_REVIEW_PROMPT:-}"
 export PI_EXCLUDE="${INPUT_EXCLUDE_PATTERNS:-*.lock package-lock.json yarn.lock pnpm-lock.yaml *.min.js *.min.css *.map}"

scripts/review.sh

@@ -70,74 +70,148 @@ chmod 600 "$AUTH_FILE"
 echo "Configured provider: ${PI_PROVIDER}"
 echo "::endgroup::"
 
-# ─── Phase 2: Generate diff ───────────────────────────────────────────────────
-echo "::group::Generate diff"
+# ─── Phase 2: Fetch diff via API ───────────────────────────────────────────────
+echo "Generate diff"
 
-# Find the base branch.
-# Strategy: check if remote tracking refs already exist (from a pre-step),
-# then try Gitea/GitHub event context, then try fetching (may fail without auth).
+# Git operations inside the Docker container have no auth credentials
+# (actions/checkout@v5 stores them in $RUNNER_TEMP, which isn't mounted).
+# Instead, we get the diff directly from the Gitea/GitHub API using the token
+# we already have for posting comments.
 
-BASE=""
+# Gitea Actions mirrors GitHub Actions env vars ($GITHUB_*) and exposes the
+# event payload at $GITHUB_EVENT_PATH. There is no flat $GITEA_EVENT_*
+# variable for the PR number, so we parse it out of the event JSON.
 
-# 1. Check if remote tracking refs already exist (e.g., workflow pre-fetch step)
-for candidate in origin/main origin/master; do
-  if git rev-parse --verify "$candidate" >/dev/null 2>&1; then
-    BASE="$candidate"
-    echo "Found existing ref: ${BASE}"
-    break
-  fi
-done
+REPO="${GITHUB_REPOSITORY:-${GITEA_REPOSITORY:-}}"
 
-# 2. Try Gitea/GitHub event context for target branch
-if [ -z "$BASE" ]; then
-  TARGET_BRANCH="${GITEA_BASE_REF:-${GITHUB_BASE_REF:-}}"
-  if [ -n "${TARGET_BRANCH}" ] && git rev-parse --verify "origin/${TARGET_BRANCH}" >/dev/null 2>&1; then
-    BASE="origin/${TARGET_BRANCH}"
-    echo "Found target branch from event: ${BASE}"
-  fi
+# Detect Gitea vs GitHub. Gitea sets $GITHUB_SERVER_URL too, so the only
+# reliable signal is $GITEA_ACTIONS (or a non-github.com server URL).
+#
+# $PI_SERVER_URL (server_url input) overrides the auto-detected server URL.
+# Gitea reports its *external* hostname (e.g. git.example.com), which may not
+# be routable from inside the runner's container network. Setting server_url
+# to the internal address (e.g. http://server:3000) fixes API calls.
+SERVER_URL="${PI_SERVER_URL:-${GITHUB_SERVER_URL:-${GITEA_SERVER_URL:-}}}"
+if [ -n "${GITEA_ACTIONS:-}" ] || { [ -n "$SERVER_URL" ] && [ "${SERVER_URL#*github.com}" = "$SERVER_URL" ]; }; then
+  API_BASE="${SERVER_URL}/api/v1"
+  PLATFORM="gitea"
+  echo "Platform: Gitea (${SERVER_URL})"
+else
+  API_BASE="${GITHUB_API_URL:-https://api.github.com}"
+  PLATFORM="github"
+  echo "Platform: GitHub"
 fi
 
-# 3. Last resort: try to fetch (will likely fail inside Docker without auth)
-if [ -z "$BASE" ]; then
-  echo "::warning::No base ref found locally. Attempting fetch (may fail without auth)..."
-  git fetch --unshallow origin 2>/dev/null || true
-  for branch in main master; do
-    if git fetch origin "refs/heads/${branch}:refs/remotes/origin/${branch}" 2>/dev/null; then
-      BASE="origin/${branch}"
-      break
-    fi
-  done
+# Resolve PR number from the event payload.
+PR_NUMBER=""
+if [ -n "${GITHUB_EVENT_PATH:-}" ] && [ -f "${GITHUB_EVENT_PATH}" ]; then
+  PR_NUMBER=$(node -e "
+    try {
+      const e = require(process.env.GITHUB_EVENT_PATH);
+      const n = (e.pull_request && e.pull_request.number) || e.number || '';
+      process.stdout.write(String(n || ''));
+    } catch { process.stdout.write(''); }
+  ")
 fi
 
-if [ -z "$BASE" ]; then
-  echo "::error::Could not determine base branch. Add a 'Fetch base branch' step before this action: git fetch origin refs/heads/main:refs/remotes/origin/main"
-  exit 1
+echo "Repo: ${REPO}, PR: ${PR_NUMBER}"
+echo "DEBUG: PLATFORM=${PLATFORM} API_BASE=${API_BASE} EVENT=${GITHUB_EVENT_PATH:-}"
+
+if [ -z "$PR_NUMBER" ]; then
+  echo "Not a pull request event. Skipping review."
+  exit 0
 fi
 
-echo "Base ref: ${BASE} -> $(git rev-parse --short "${BASE}" 2>/dev/null || echo 'NOT FOUND')"
-echo "HEAD:     $(git rev-parse --short HEAD)"
-echo "Files changed:"
-git diff --stat "${BASE}...HEAD" 2>/dev/null | tail -3 || echo "(could not stat diff)"
+# Fetch diff via API — works regardless of git auth inside the container.
+# Gitea: GET /repos/{owner}/{repo}/pulls/{index}.diff
+# GitHub: GET /repos/{owner}/{repo}/pulls/{index} (Accept: application/diff)
+node -e "
+const http = require('http');
+const https = require('https');
 
-# Build exclude pathspecs
-EXCLUDE_ARGS=""
-for pattern in $PI_EXCLUDE; do
-  EXCLUDE_ARGS="$EXCLUDE_ARGS ':!$pattern'"
-done
+const apiBase = '${API_BASE}';
+const repo = '${REPO}';
+const prNumber = '${PR_NUMBER}';
+const token = '${PI_TOKEN}';
+const platform = '${PLATFORM}';
+const maxBytes = ${PI_MAX_DIFF:-80000};
 
-eval "git diff ${BASE}...HEAD ${EXCLUDE_ARGS}" > /tmp/pi-diff.txt 2>/dev/null || true
+function fetchDiff() {
+  return new Promise((resolve, reject) => {
+    // Gitea:  GET {api}/repos/{owner}/{repo}/pulls/{n}.diff
+    // GitHub: GET {api}/repos/{owner}/{repo}/pulls/{n} with Accept: application/vnd.github.v3.diff
+    const path = platform === 'gitea'
+      ? '/repos/' + repo + '/pulls/' + prNumber + '.diff'
+      : '/repos/' + repo + '/pulls/' + prNumber;
 
-# Truncate if needed
-if [ "${PI_MAX_DIFF}" -gt 0 ]; then
-  head -c "${PI_MAX_DIFF}" /tmp/pi-diff.txt > /tmp/pi-diff-trunc.txt
-  mv /tmp/pi-diff-trunc.txt /tmp/pi-diff.txt
-fi
+    const url = new URL(apiBase + path);
+    const transport = url.protocol === 'http:' ? http : https;
 
-DIFF_SIZE=$(wc -c < /tmp/pi-diff.txt || echo 0)
-echo "Diff size: ${DIFF_SIZE} bytes"
-echo "::endgroup::"
+    const headers = {
+      'Authorization': 'token ' + token,
+      'User-Agent': 'pi-code-review',
+      'Accept': platform === 'gitea' ? 'text/plain' : 'application/vnd.github.v3.diff',
+    };
 
-if [ "${DIFF_SIZE}" -eq 0 ]; then
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'http:' ? 80 : 443),
+      path: url.pathname,
+      method: 'GET',
+      headers,
+    };
+
+    const req = transport.request(options, (res) => {
+      if (res.statusCode < 200 || res.statusCode >= 300) {
+        let body = '';
+        res.on('data', (c) => { body += c; });
+        res.on('end', () => { reject(new Error('API ' + res.statusCode + ' for ' + url.href + ': ' + body.slice(0, 200))); });
+        return;
+      }
+
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => { resolve(data); });
+    });
+    req.on('error', (e) => { reject(e); });
+    req.end();
+  });
+}
+
+fetchDiff().then((diff) => {
+  const fs = require('fs');
+
+  // Filter out excluded patterns (lockfiles, generated code, etc.)
+  const excludePatterns = '${PI_EXCLUDE}'.split(' ').filter(Boolean);
+  if (excludePatterns.length > 0) {
+    const lines = diff.split('\\n');
+    const filtered = [];
+    let skipFile = false;
+    for (const line of lines) {
+      if (line.startsWith('diff --git')) {
+        skipFile = excludePatterns.some(p => {
+          const glob = p.replace(/\\./g, '\\\\.').replace(/\\*/g, '.*');
+          return new RegExp(glob).test(line);
+        });
+      }
+      if (!skipFile) filtered.push(line);
+    }
+    diff = filtered.join('\\n');
+  }
+
+  if (maxBytes > 0 && diff.length > maxBytes) {
+    diff = diff.slice(0, maxBytes) + '\\n... (truncated at ' + maxBytes + ' bytes)';
+  }
+
+  fs.writeFileSync('/tmp/pi-diff.txt', diff);
+  console.log('Diff fetched: ' + diff.length + ' bytes');
+}).catch((e) => {
+  console.error('Failed to fetch diff: ' + e.message);
+  process.exit(1);
+});
+"
+
+if [ ! -s /tmp/pi-diff.txt ]; then
   echo "No changes to review. Skipping."
   exit 0
 fi
@@ -181,14 +255,21 @@ if [ ! -s /tmp/pi-review.md ]; then
   exit 1
 fi
 
+echo "Debug mode: PI_DEBUG=${PI_DEBUG}"
+
 # If debug mode, extract tool calls from session and append to review
 if [ "${PI_DEBUG}" = "true" ]; then
+  echo "Session dir contents:"
+  find /tmp/pi-session -type f 2>/dev/null || echo "  (none)"
   SESSION_FILE=$(find /tmp/pi-session -name '*.jsonl' -type f 2>/dev/null | head -1)
+  echo "Session file: ${SESSION_FILE:-<none found>}"
   TOOL_LOG=""
 
   if [ -n "${SESSION_FILE}" ]; then
-    # Extract tool-use entries: each line is a JSON object.
-    # Tool calls appear as messages with tool_use/function_call content.
+    # Extract tool-call entries from Pi session JSONL.
+    # Pi stores assistant messages with content blocks of type "toolCall"
+    # (NOT the Anthropic SDK's "tool_use"), using "arguments" (NOT "input").
+    # Tool results are separate entries with role "toolResult".
     TOOL_LOG=$(node -e "
       const fs = require('fs');
       const lines = fs.readFileSync('${SESSION_FILE}', 'utf8').trim().split('\n');
@@ -196,20 +277,18 @@ if [ "${PI_DEBUG}" = "true" ]; then
       for (const line of lines) {
         try {
           const entry = JSON.parse(line);
-          if (entry.type === 'message') {
+          if (entry.type !== 'message') continue;
           const msg = entry.message;
-            // Model requesting tool use
-            if (msg.role === 'assistant' && msg.content) {
+          if (!msg || !msg.content) continue;
           const parts = Array.isArray(msg.content) ? msg.content : [msg.content];
           for (const part of parts) {
-                if (typeof part === 'object' && part.type === 'tool_use') {
-                  const input = part.input || {};
-                  const args = Object.entries(input).map(([k,v]) => k + '=' + JSON.stringify(v)).join(' ');
+            if (typeof part !== 'object') continue;
+            if (part.type === 'toolCall') {
+              const args = Object.entries(part.arguments || {})
+                .map(([k,v]) => k + '=' + JSON.stringify(v)).join(' ');
               entries.push('[tool:' + part.name + '] ' + args);
             }
           }
-            }
-          }
         } catch {}
       }
       console.log(entries.join('\n'));
@@ -242,17 +321,7 @@ echo "::endgroup::"
 # ─── Phase 4: Post comment ────────────────────────────────────────────────────
 echo "::group::Post review comment"
 
-# Detect Gitea vs GitHub
-if [ -n "${GITEA_SERVER_URL:-}" ]; then
-  API_BASE="${GITEA_SERVER_URL}/api/v1"
-  PR_NUMBER="${GITEA_EVENT_PULL_REQUEST_NUMBER:-}"
-  REPO="${GITEA_REPOSITORY:-}"
-else
-  API_BASE="${GITHUB_API_URL:-https://api.github.com}"
-  PR_NUMBER="${GITHUB_EVENT_PULL_REQUEST_NUMBER:-}"
-  REPO="${GITHUB_REPOSITORY:-}"
-fi
-
+# API_BASE / REPO / PR_NUMBER were resolved in Phase 2.
 if [ -z "$PR_NUMBER" ]; then
   echo "Not a pull request event. Review written to /tmp/pi-review.md only."
   echo "::endgroup::"