@shipfox/api-integration-github 12.6.0 → 12.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-integration-github",
   "license": "MIT",
-  "version": "12.6.0",
+  "version": "12.7.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",

package/src/core/agent-tools.test.ts

@@ -83,6 +83,7 @@ const expectedCatalogRows = [
       'get_files',
       'get_commits',
       'get_review_comments',
+      'get_review_threads',
       'get_reviews',
       'get_comments',
       'get_check_runs',
@@ -148,6 +149,14 @@ const expectedCatalogRows = [
     requiredScope: [{permission: 'pull_requests', access: 'write'}],
     methods: ['create', 'submit_pending', 'delete_pending'],
   },
+  {
+    id: 'pull_request_review_thread_write',
+    category: 'pull_requests',
+    sensitivity: 'write',
+    sensitive: false,
+    requiredScope: [{permission: 'pull_requests', access: 'write'}],
+    methods: ['resolve'],
+  },
   {
     id: 'add_comment_to_pending_review',
     category: 'pull_requests',
@@ -351,6 +360,12 @@ const githubOperationRouteCases = [
     args: {pull_number: 1},
     expectedRoute: 'GET /repos/{owner}/{repo}/pulls/{pull_number}/comments',
   },
+  {
+    toolId: 'pull_request_read',
+    method: 'get_review_threads',
+    args: {pull_number: 1},
+    expectedRoute: 'POST /graphql',
+  },
   {
     toolId: 'pull_request_read',
     method: 'get_reviews',
@@ -429,6 +444,12 @@ const githubOperationRouteCases = [
     runtimeInjectedProperties: ['review_id'],
     expectedRoute: 'DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}',
   },
+  {
+    toolId: 'pull_request_review_thread_write',
+    method: 'resolve',
+    args: {thread_id: 'PRRT_kwDOExample'},
+    expectedRoute: 'POST /graphql',
+  },
   {
     toolId: 'add_comment_to_pending_review',
     args: {pull_number: 1, path: 'src/index.ts', body: 'Comment'},
@@ -663,6 +684,7 @@ describe('github agent tool catalog', () => {
       {properties: {method: {const: 'get_files'}}, required: []},
       {properties: {method: {const: 'get_commits'}}, required: []},
       {properties: {method: {const: 'get_review_comments'}}, required: []},
+      {properties: {method: {const: 'get_review_threads'}}, required: []},
       {properties: {method: {const: 'get_reviews'}}, required: []},
       {properties: {method: {const: 'get_comments'}}, required: []},
       {properties: {method: {const: 'get_check_runs'}}, required: ['ref']},
@@ -841,6 +863,104 @@ describe('github agent tool catalog', () => {
     });
   });
 
+  it('reads pull request review threads through GraphQL', async () => {
+    const request = vi.fn();
+    const data = {
+      repository: {
+        pullRequest: {
+          reviewThreads: {
+            nodes: [
+              {
+                id: 'PRRT_kwDOExample',
+                isResolved: false,
+                comments: {
+                  nodes: [
+                    {
+                      id: 'PRRC_kwDOExample',
+                      databaseId: 7,
+                      body: 'Please handle this.',
+                      author: {login: 'reviewer'},
+                      path: 'src/index.ts',
+                      line: 42,
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        },
+      },
+    };
+    const graphql = vi.fn().mockResolvedValueOnce(data);
+    const provider = createAgentToolsProvider({request, graphql});
+    const session = await provider.openSession({
+      connection: connection(),
+      tools: [pullRequestReadTool()],
+      scope: undefined,
+    });
+
+    const result = await session.call({
+      toolId: 'pull_request_read',
+      arguments: {
+        method: 'get_review_threads',
+        owner: 'shipfox',
+        repo: 'platform',
+        pull_number: 2,
+        cursor: 'cursor-1',
+      },
+    });
+
+    expect(request).not.toHaveBeenCalled();
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('reviewThreads(first: 100, after: $after)'),
+      {owner: 'shipfox', repo: 'platform', pullNumber: 2, after: 'cursor-1'},
+    );
+    const query = graphql.mock.calls[0]?.[0];
+    expect(query).toContain('isResolved');
+    expect(query).toContain('author');
+    expect(query).toContain('path');
+    expect(query).toContain('line');
+    expect(result).toEqual({
+      content: [{type: 'text', text: JSON.stringify(data)}],
+      structuredContent: data,
+    });
+  });
+
+  it('resolves a pull request review thread through GraphQL', async () => {
+    const request = vi.fn();
+    const data = {
+      resolveReviewThread: {
+        thread: {id: 'PRRT_kwDOExample', isResolved: true},
+      },
+    };
+    const graphql = vi.fn().mockResolvedValueOnce(data);
+    const provider = createAgentToolsProvider({request, graphql});
+    const session = await provider.openSession({
+      connection: connection(),
+      tools: [pullRequestReviewThreadWriteTool()],
+      scope: undefined,
+    });
+
+    const result = await session.call({
+      toolId: 'pull_request_review_thread_write',
+      arguments: {
+        method: 'resolve',
+        owner: 'shipfox',
+        repo: 'platform',
+        thread_id: 'PRRT_kwDOExample',
+      },
+    });
+
+    expect(request).not.toHaveBeenCalled();
+    expect(graphql).toHaveBeenCalledWith(expect.stringContaining('resolveReviewThread'), {
+      input: {threadId: 'PRRT_kwDOExample'},
+    });
+    expect(result).toEqual({
+      content: [{type: 'text', text: JSON.stringify(data)}],
+      structuredContent: data,
+    });
+  });
+
   it('projects issue comment reactions through the provider session', async () => {
     const request = vi.fn(() => Promise.resolve({data: {id: 7}}));
     const result = await callGithubToolWithRequest(
@@ -1546,6 +1666,20 @@ function pendingReviewTool() {
   return tool;
 }
 
+function pullRequestReadTool() {
+  const tool = githubAgentToolCatalog.find((entry) => entry.id === 'pull_request_read');
+  if (!tool) throw new Error('Missing pull_request_read tool');
+  return tool;
+}
+
+function pullRequestReviewThreadWriteTool() {
+  const tool = githubAgentToolCatalog.find(
+    (entry) => entry.id === 'pull_request_review_thread_write',
+  );
+  if (!tool) throw new Error('Missing pull_request_review_thread_write tool');
+  return tool;
+}
+
 function connection() {
   return {
     id: 'connection-1',

package/src/core/agent-tools.ts

@@ -78,6 +78,63 @@ const ADD_PENDING_REVIEW_COMMENT_MUTATION = `
   }
 `;
 
+const GET_PULL_REQUEST_REVIEW_THREADS_QUERY = `
+  query GetPullRequestReviewThreads(
+    $owner: String!
+    $repo: String!
+    $pullNumber: Int!
+    $after: String
+  ) {
+    repository(owner: $owner, name: $repo) {
+      pullRequest(number: $pullNumber) {
+        reviewThreads(first: 100, after: $after) {
+          nodes {
+            id
+            isResolved
+            comments(first: 100) {
+              nodes {
+                id
+                databaseId
+                body
+                author {
+                  login
+                }
+                path
+                line
+                side
+                startLine
+                startSide
+                createdAt
+                updatedAt
+                url
+              }
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+            }
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }
+    }
+  }
+`;
+
+const RESOLVE_PULL_REQUEST_REVIEW_THREAD_MUTATION = `
+  mutation ResolvePullRequestReviewThread($input: ResolveReviewThreadInput!) {
+    resolveReviewThread(input: $input) {
+      thread {
+        id
+        isResolved
+      }
+    }
+  }
+`;
+
 export class GithubAgentToolsProvider
   implements
     AgentToolsProvider<
@@ -145,11 +202,17 @@ export class GithubAgentToolsProvider
 
         if (operation.kind === 'graphql') {
           const data = await mapGithubError(() =>
-            addCommentToPendingReview(client, operation.parameters),
+            executeGithubGraphqlOperation(
+              client,
+              tool.id as GithubAgentToolId,
+              method,
+              operation.parameters,
+            ),
           );
-          return data === undefined
-            ? githubToolError(NO_PENDING_REVIEW_MESSAGE, 'provider-rejected')
-            : githubToolResult(tool.id as GithubAgentToolId, data);
+          if (data === undefined && tool.id === 'add_comment_to_pending_review') {
+            return githubToolError(NO_PENDING_REVIEW_MESSAGE, 'provider-rejected');
+          }
+          return githubToolResult(tool.id as GithubAgentToolId, data);
         }
 
         const operationParameters = await mapGithubError(() =>
@@ -322,6 +385,8 @@ export function githubOperationRoute(
       return `GET ${repoPath}/pulls/${pull}/commits`;
     case 'pull_request_read.get_review_comments':
       return `GET ${repoPath}/pulls/${pull}/comments`;
+    case 'pull_request_read.get_review_threads':
+      return GITHUB_GRAPHQL_ROUTE;
     case 'pull_request_read.get_reviews':
       return `GET ${repoPath}/pulls/${pull}/reviews`;
     case 'pull_request_read.get_comments':
@@ -350,6 +415,8 @@ export function githubOperationRoute(
       return `POST ${repoPath}/pulls/${pull}/reviews/{review_id}/events`;
     case 'pull_request_review_write.delete_pending':
       return `DELETE ${repoPath}/pulls/${pull}/reviews/{review_id}`;
+    case 'pull_request_review_thread_write.resolve':
+      return GITHUB_GRAPHQL_ROUTE;
     case 'add_comment_to_pending_review.':
       return GITHUB_GRAPHQL_ROUTE;
     case 'actions_list.list_workflows':
@@ -423,6 +490,43 @@ async function addCommentToPendingReview(
   return await client.graphql(ADD_PENDING_REVIEW_COMMENT_MUTATION, {input});
 }
 
+async function executeGithubGraphqlOperation(
+  client: GithubToolClient,
+  toolId: GithubAgentToolId,
+  method: string | undefined,
+  parameters: Record<string, unknown>,
+): Promise<unknown | undefined> {
+  if (client.graphql === undefined) {
+    throw new GithubIntegrationProviderError(
+      'malformed-provider-response',
+      'GitHub client does not support GraphQL operations',
+    );
+  }
+
+  switch (`${toolId}.${method ?? ''}`) {
+    case 'pull_request_read.get_review_threads': {
+      const variables: Record<string, unknown> = {
+        owner: parameters.owner,
+        repo: parameters.repo,
+        pullNumber: parameters.pull_number,
+      };
+      if (typeof parameters.cursor === 'string') variables.after = parameters.cursor;
+      return await client.graphql(GET_PULL_REQUEST_REVIEW_THREADS_QUERY, variables);
+    }
+    case 'pull_request_review_thread_write.resolve':
+      return await client.graphql(RESOLVE_PULL_REQUEST_REVIEW_THREAD_MUTATION, {
+        input: {threadId: parameters.thread_id},
+      });
+    case 'add_comment_to_pending_review.':
+      return await addCommentToPendingReview(client, parameters);
+    default:
+      throw new GithubIntegrationProviderError(
+        'malformed-provider-response',
+        'GitHub operation does not support GraphQL operations',
+      );
+  }
+}
+
 export function projectGithubOperationParameters(
   toolId: GithubAgentToolId,
   method: string | undefined,

package/src/core/github-agent-tool-catalog.ts

@@ -174,6 +174,13 @@ const pullRequestReadMethods = [
     false,
     scopes.pullRequestsRead,
   ),
+  method(
+    'get_review_threads',
+    'Get review threads, their resolution state, and comments for a specific pull request.',
+    'read',
+    false,
+    scopes.pullRequestsRead,
+  ),
   method(
     'get_reviews',
     'Get reviews for a specific pull request.',
@@ -221,6 +228,16 @@ const pullRequestReviewWriteMethods = [
   ),
 ] as const satisfies readonly GithubAgentToolCatalogMethod[];
 
+const pullRequestReviewThreadWriteMethods = [
+  method(
+    'resolve',
+    'Resolve a pull request review thread.',
+    'write',
+    false,
+    scopes.pullRequestsWrite,
+  ),
+] as const satisfies readonly GithubAgentToolCatalogMethod[];
+
 const actionsListMethods = [
   method('list_workflows', 'List workflows in a repository.', 'read', false, scopes.actionsRead),
   method(
@@ -472,6 +489,7 @@ export const githubAgentToolCatalog = [
           methodRequiredSchema('get_files', []),
           methodRequiredSchema('get_commits', []),
           methodRequiredSchema('get_review_comments', []),
+          methodRequiredSchema('get_review_threads', []),
           methodRequiredSchema('get_reviews', []),
           methodRequiredSchema('get_comments', []),
           methodRequiredSchema('get_check_runs', ['ref']),
@@ -666,6 +684,23 @@ export const githubAgentToolCatalog = [
     ),
     outputSchema: openObjectSchema('Pull request review write result'),
   }),
+  tool({
+    id: 'pull_request_review_thread_write',
+    category: 'pull_requests',
+    description: 'Resolve review threads on a pull request in a GitHub repository.',
+    methods: pullRequestReviewThreadWriteMethods,
+    inputSchema: repositoryInputSchema(
+      {
+        method: methodSchema(
+          pullRequestReviewThreadWriteMethods,
+          'The write operation to perform on a pull request review thread',
+        ),
+        thread_id: stringSchema('The node ID of the review thread'),
+      },
+      ['method', 'thread_id'],
+    ),
+    outputSchema: openObjectSchema('Pull request review thread write result'),
+  }),
   tool({
     id: 'add_comment_to_pending_review',
     category: 'pull_requests',