Expose GitHub Context out of tag mode

[atsushi-ishibashi]

@ashwin-ant @km-anthropic
I’d like to use the GitHub context that’s currently structured in tag mode also in agent mode. I know it can be done using the method described in custom-automations, but reproducing exactly what tag mode does is quite difficult. Another challenge is that the property for determining hidden comments can’t be retrieved via the REST API.

Related to #492, what do you think about the approach of having the context that tag mode builds set as environment variables, and then making it available to the prompt (so it can be used in bash)? If we agree on this direction, I can take care of the implementation.

[atsushi-ishibashi]

Here’s the YAML currently under implementation.

name: Claude Plan Mode

on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]
  issues:
    types: [opened, assigned]
  pull_request_review:
    types: [submitted]

jobs:
  plan-mode:
    if: |
      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))

    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 1

      - name: Build GitHub Context
        id: build-context
        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
        with:
          script: |
            const fs = require('fs');
            
            // Helper function to safely get nested properties
            const safeGet = (obj, path, defaultValue = '') => {
              try {
                return path.split('.').reduce((o, p) => o?.[p], obj) || defaultValue;
              } catch {
                return defaultValue;
              }
            };
            
            // Determine if this is a PR or Issue
            const isPR = context.eventName === 'pull_request_review_comment' || 
                        context.eventName === 'pull_request_review' ||
                        (context.eventName === 'issue_comment' && context.payload.issue.pull_request);
            
            const entityNumber = isPR ? 
              (context.payload.pull_request?.number || context.payload.issue?.number) :
              context.payload.issue?.number;
            
            let contextData = {
              repository: context.repo,
              eventName: context.eventName,
              actor: context.actor,
              sha: context.sha,
              ref: context.ref,
              isPR: isPR,
              entityNumber: entityNumber,
              triggerPhrase: '@claude'
            };
            
            // Get basic entity info
            if (isPR) {
              const prData = context.payload.pull_request || context.payload.issue;
              contextData.pr = {
                title: prData.title,
                body: prData.body || 'No description provided',
                state: prData.state,
                author: prData.user.login,
                baseBranch: prData.base?.ref || context.payload.pull_request?.base?.ref,
                headBranch: prData.head?.ref || context.payload.pull_request?.head?.ref,
                number: entityNumber
              };
              
              // Fetch PR comments, reviews, and files
              try {
                const [comments, reviews, files] = await Promise.all([
                  github.rest.issues.listComments({
                    owner: context.repo.owner,
                    repo: context.repo.repo,
                    issue_number: entityNumber,
                    per_page: 100
                  }),
                  github.rest.pulls.listReviews({
                    owner: context.repo.owner,
                    repo: context.repo.repo,
                    pull_number: entityNumber,
                    per_page: 100
                  }),
                  github.rest.pulls.listFiles({
                    owner: context.repo.owner,
                    repo: context.repo.repo,
                    pull_number: entityNumber,
                    per_page: 100
                  })
                ]);
                
                contextData.comments = comments.data.map(comment => ({
                  author: comment.user.login,
                  body: comment.body,
                  createdAt: comment.created_at,
                  id: comment.id
                }));
                
                contextData.reviews = reviews.data.map(review => ({
                  author: review.user.login,
                  body: review.body || '',
                  state: review.state,
                  createdAt: review.submitted_at,
                  id: review.id
                }));
                
                contextData.changedFiles = files.data.map(file => ({
                  filename: file.filename,
                  status: file.status,
                  additions: file.additions,
                  deletions: file.deletions,
                  changes: file.changes,
                  patch: file.patch?.substring(0, 5000) // Limit patch size
                }));
                
                // Get review comments
                const reviewComments = await github.rest.pulls.listReviewComments({
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  pull_number: entityNumber,
                  per_page: 100
                });
                
                contextData.reviewComments = reviewComments.data.map(comment => ({
                  author: comment.user.login,
                  body: comment.body,
                  path: comment.path,
                  line: comment.line,
                  createdAt: comment.created_at,
                  diffHunk: comment.diff_hunk,
                  id: comment.id
                }));
                
              } catch (error) {
                console.log('Error fetching PR data:', error.message);
                contextData.comments = [];
                contextData.reviews = [];
                contextData.changedFiles = [];
                contextData.reviewComments = [];
              }
              
            } else {
              // Handle Issue
              const issueData = context.payload.issue;
              contextData.issue = {
                title: issueData.title,
                body: issueData.body || 'No description provided',
                state: issueData.state,
                author: issueData.user.login,
                labels: issueData.labels.map(label => label.name),
                assignees: issueData.assignees.map(assignee => assignee.login),
                number: entityNumber
              };
              
              // Fetch issue comments
              try {
                const comments = await github.rest.issues.listComments({
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  issue_number: entityNumber,
                  per_page: 100
                });
                
                contextData.comments = comments.data.map(comment => ({
                  author: comment.user.login,
                  body: comment.body,
                  createdAt: comment.created_at,
                  id: comment.id
                }));
                
              } catch (error) {
                console.log('Error fetching issue comments:', error.message);
                contextData.comments = [];
              }
            }
            
            // Get trigger comment
            if (context.eventName === 'issue_comment') {
              contextData.triggerComment = {
                author: context.payload.comment.user.login,
                body: context.payload.comment.body,
                createdAt: context.payload.comment.created_at
              };
            } else if (context.eventName === 'pull_request_review_comment') {
              contextData.triggerComment = {
                author: context.payload.comment.user.login,
                body: context.payload.comment.body,
                createdAt: context.payload.comment.created_at
              };
            } else if (context.eventName === 'pull_request_review') {
              contextData.triggerComment = {
                author: context.payload.review.user.login,
                body: context.payload.review.body || '',
                createdAt: context.payload.review.submitted_at
              };
            } else if (context.eventName === 'issues') {
              contextData.triggerComment = {
                author: context.payload.issue.user.login,
                body: context.payload.issue.body || '',
                createdAt: context.payload.issue.created_at
              };
            }
            
            // Format context similar to Tag Mode's generatePrompt
            let contextText = `<formatted_context>
            Repository: ${contextData.repository.owner}/${contextData.repository.repo}
            Event Type: ${contextData.eventName}
            Actor: ${contextData.actor}
            SHA: ${contextData.sha}
            Ref: ${contextData.ref}
            ${isPR ? `PR Number: ${entityNumber}` : `Issue Number: ${entityNumber}`}
            Type: ${isPR ? 'Pull Request' : 'Issue'}
            </formatted_context>

            `;

            // Add PR or Issue body
            const entityBody = isPR ? contextData.pr.body : contextData.issue.body;
            contextText += `<pr_or_issue_body>
            ${entityBody}
            </pr_or_issue_body>\n\n`;

            // Add comments
            if (contextData.comments && contextData.comments.length > 0) {
              contextText += `<comments>\n`;
              contextData.comments.forEach((comment, index) => {
                contextText += `**Comment ${index + 1}** by @${comment.author} (${comment.createdAt}):\n${comment.body}\n\n`;
              });
              contextText += `</comments>\n\n`;
            } else {
              contextText += `<comments>\nNo comments\n</comments>\n\n`;
            }

            // Add review comments for PRs
            if (isPR && contextData.reviewComments && contextData.reviewComments.length > 0) {
              contextText += `<review_comments>\n`;
              contextData.reviewComments.forEach((comment, index) => {
                contextText += `**Review Comment ${index + 1}** by @${comment.author} on ${comment.path}:${comment.line} (${comment.createdAt}):\n`;
                contextText += `\`\`\`diff\n${comment.diffHunk}\n\`\`\`\n`;
                contextText += `${comment.body}\n\n`;
              });
              contextText += `</review_comments>\n\n`;
            } else if (isPR) {
              contextText += `<review_comments>\nNo review comments\n</review_comments>\n\n`;
            }

            // Add reviews for PRs
            if (isPR && contextData.reviews && contextData.reviews.length > 0) {
              contextText += `<reviews>\n`;
              contextData.reviews.forEach((review, index) => {
                contextText += `**Review ${index + 1}** by @${review.author} (${review.state}, ${review.createdAt}):\n${review.body || 'No review body'}\n\n`;
              });
              contextText += `</reviews>\n\n`;
            } else if (isPR) {
              contextText += `<reviews>\nNo reviews\n</reviews>\n\n`;
            }

            // Add changed files for PRs
            if (isPR && contextData.changedFiles && contextData.changedFiles.length > 0) {
              contextText += `<changed_files>\n`;
              contextData.changedFiles.forEach((file, index) => {
                contextText += `**File ${index + 1}**: ${file.filename} (${file.status})\n`;
                contextText += `+${file.additions} -${file.deletions} changes: ${file.changes}\n`;
                if (file.patch) {
                  contextText += `\`\`\`diff\n${file.patch}\n\`\`\`\n`;
                }
                contextText += `\n`;
              });
              contextText += `</changed_files>\n\n`;
            } else if (isPR) {
              contextText += `<changed_files>\nNo files changed\n</changed_files>\n\n`;
            }

            // Add trigger comment
            contextText += `<trigger_comment>
            ${contextData.triggerComment.body}
            </trigger_comment>\n\n`;

            // Add metadata
            contextText += `<event_type>${contextData.eventName}</event_type>
            <is_pr>${isPR ? 'true' : 'false'}</is_pr>
            <trigger_context>@claude mentioned in ${contextData.eventName}</trigger_context>
            <repository>${contextData.repository.owner}/${contextData.repository.repo}</repository>
            ${isPR ? `<pr_number>${entityNumber}</pr_number>` : `<issue_number>${entityNumber}</issue_number>`}
            <trigger_username>${contextData.actor}</trigger_username>
            <trigger_display_name>${contextData.actor}</trigger_display_name>
            <trigger_phrase>@claude</trigger_phrase>
            `;

            // Write formatted context to file
            fs.writeFileSync('github-context.txt', contextText);
            
            console.log('GitHub context prepared and saved to github-context.txt');
            // Create initial tracking comment for Plan Mode
            const commentBody = `### Plan Mode Analysis <img src="https://github.com/user-attachments/assets/5ac382c7-e004-429b-8e35-7feb3e8f9c6f" width="14px" height="14px" style="vertical-align: middle; margin-left: 4px;" />
            I'm analyzing your request. Here's my progress:
            
            #### Todo List:
            - [ ] Load GitHub context
            - [ ] Understand the request
            - [ ] Execute analysis
            - [ ] Provide final results
            
            Currently loading context...`;
            
            let commentData;
            if (isPR) {
              commentData = await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: entityNumber,
                body: commentBody
              });
            } else {
              commentData = await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: entityNumber,
                body: commentBody
              });
            }

            console.log('Created tracking comment with ID:', commentData.data.id);
            core.setOutput('claude_comment_id', commentData.data.id.toString());
            return contextData;

      - name: Run Claude Plan Mode
        uses: anthropics/claude-code-action@c05ccc5ce416f3129e97c8d17188813fef66f002 # v1.0.1
        env:
            CLAUDE_COMMENT_ID: ${{ steps.build-context.outputs.claude_comment_id }}
        with:
          trigger_phrase: "@claude"
          prompt: |
            ## Context Loading Instructions

            **CRITICAL FIRST STEP**: The GitHub context data has been pre-fetched and is available in the file `github-context.txt`. You MUST use the Read tool to load this context data at the very beginning of your analysis. This file contains:
            - Repository information and event details
            - Issue/PR details (title, body, state, author, etc.)
            - Complete comment history and thread
            - For PRs: Reviews, review comments, and changed files with diffs
            - For Issues: Labels, assignees, and full comment thread
            - Trigger comment that contains '@claude' request

            // custom prompt

          claude_args: |
            --model us.anthropic.claude-sonnet-4-20250514-v1:0
            --allowedTools Read,Grep,LS,Glob,mcp__github_comment__update_claude_comment,Task,TodoWrite

[maxired]

I do agree that it would be usefull to get same tools as tag for other conditions.
My use cases is doing PR review when a PR is labelled