@loopstack/github-module 0.1.0

package/src/tools/issues/github-get-issue.tool.ts

@@ -0,0 +1,115 @@
+import { Inject, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { OAuthTokenStore } from '@loopstack/oauth-module';
+
+export type GitHubGetIssueArgs = {
+  owner: string;
+  repo: string;
+  issueNumber: number;
+};
+
+@Tool({
+  config: {
+    description:
+      'Gets detailed information about a specific GitHub issue. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubGetIssueTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubGetIssueTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        owner: z.string(),
+        repo: z.string(),
+        issueNumber: z.number(),
+      })
+      .strict(),
+  })
+  args: GitHubGetIssueArgs;
+
+  async execute(args: GitHubGetIssueArgs, ctx: RunContext): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+
+    if (!accessToken) {
+      return {
+        data: {
+          error: 'unauthorized',
+          message: 'No valid GitHub token found. Please authenticate first.',
+        },
+      };
+    }
+
+    const url = `https://api.github.com/repos/${encodeURIComponent(args.owner)}/${encodeURIComponent(args.repo)}/issues/${args.issueNumber}`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      return {
+        data: {
+          error: '401',
+          message: 'GitHub token was rejected. Please re-authenticate.',
+        },
+      };
+    }
+
+    if (!response.ok) {
+      const body = await response.text();
+      this.logger.error(`GitHub API error: ${response.status} ${body}`);
+      return {
+        data: {
+          error: 'api_error',
+          message: `GitHub API error: ${response.statusText}`,
+        },
+      };
+    }
+
+    const issue = (await response.json()) as {
+      id: number;
+      number: number;
+      title: string;
+      body: string | null;
+      state: string;
+      user: { login: string };
+      labels: Array<{ name: string }>;
+      assignees: Array<{ login: string }>;
+      milestone: { title: string } | null;
+      created_at: string;
+      updated_at: string;
+      closed_at: string | null;
+      html_url: string;
+      comments: number;
+    };
+
+    return {
+      data: {
+        issue: {
+          id: issue.id,
+          number: issue.number,
+          title: issue.title,
+          body: issue.body,
+          state: issue.state,
+          user: issue.user.login,
+          labels: issue.labels.map((l) => l.name),
+          assignees: issue.assignees.map((a) => a.login),
+          milestone: issue.milestone?.title ?? null,
+          createdAt: issue.created_at,
+          updatedAt: issue.updated_at,
+          closedAt: issue.closed_at,
+          htmlUrl: issue.html_url,
+          comments: issue.comments,
+        },
+      },
+    };
+  }
+}

package/src/tools/issues/github-list-issues.tool.ts

@@ -0,0 +1,126 @@
+import { Inject, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { OAuthTokenStore } from '@loopstack/oauth-module';
+
+export type GitHubListIssuesArgs = {
+  owner: string;
+  repo: string;
+  state?: string;
+  labels?: string;
+  assignee?: string;
+  perPage?: number;
+  page?: number;
+};
+
+@Tool({
+  config: {
+    description:
+      'Lists issues for a GitHub repository. Note: the GitHub API returns both issues and pull requests; pull requests have a pull_request key. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubListIssuesTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubListIssuesTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        owner: z.string(),
+        repo: z.string(),
+        state: z.enum(['open', 'closed', 'all']).default('open'),
+        labels: z.string().optional(),
+        assignee: z.string().optional(),
+        perPage: z.number().default(30),
+        page: z.number().default(1),
+      })
+      .strict(),
+  })
+  args: GitHubListIssuesArgs;
+
+  async execute(args: GitHubListIssuesArgs, ctx: RunContext): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+
+    if (!accessToken) {
+      return {
+        data: {
+          error: 'unauthorized',
+          message: 'No valid GitHub token found. Please authenticate first.',
+        },
+      };
+    }
+
+    const params = new URLSearchParams({
+      state: args.state ?? 'open',
+      per_page: String(args.perPage ?? 30),
+      page: String(args.page ?? 1),
+    });
+
+    if (args.labels) params.set('labels', args.labels);
+    if (args.assignee) params.set('assignee', args.assignee);
+
+    const url = `https://api.github.com/repos/${encodeURIComponent(args.owner)}/${encodeURIComponent(args.repo)}/issues?${params.toString()}`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      return {
+        data: {
+          error: '401',
+          message: 'GitHub token was rejected. Please re-authenticate.',
+        },
+      };
+    }
+
+    if (!response.ok) {
+      const body = await response.text();
+      this.logger.error(`GitHub API error: ${response.status} ${body}`);
+      return {
+        data: {
+          error: 'api_error',
+          message: `GitHub API error: ${response.statusText}`,
+        },
+      };
+    }
+
+    const data = (await response.json()) as Array<{
+      id: number;
+      number: number;
+      title: string;
+      state: string;
+      user: { login: string };
+      labels: Array<{ name: string }>;
+      assignees: Array<{ login: string }>;
+      created_at: string;
+      updated_at: string;
+      html_url: string;
+      pull_request?: unknown;
+    }>;
+
+    const issues = data.map((issue) => ({
+      id: issue.id,
+      number: issue.number,
+      title: issue.title,
+      state: issue.state,
+      user: issue.user.login,
+      labels: issue.labels.map((l) => l.name),
+      assignees: issue.assignees.map((a) => a.login),
+      createdAt: issue.created_at,
+      updatedAt: issue.updated_at,
+      htmlUrl: issue.html_url,
+      isPullRequest: !!issue.pull_request,
+    }));
+
+    return {
+      data: { issues },
+    };
+  }
+}

package/src/tools/pull-requests/github-create-pull-request.tool.ts

@@ -0,0 +1,119 @@
+import { Inject, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { OAuthTokenStore } from '@loopstack/oauth-module';
+
+export type GitHubCreatePullRequestArgs = {
+  owner: string;
+  repo: string;
+  title: string;
+  head: string;
+  base: string;
+  body?: string;
+  draft?: boolean;
+};
+
+@Tool({
+  config: {
+    description:
+      'Creates a new pull request in a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubCreatePullRequestTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubCreatePullRequestTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        owner: z.string(),
+        repo: z.string(),
+        title: z.string(),
+        head: z.string(),
+        base: z.string(),
+        body: z.string().optional(),
+        draft: z.boolean().default(false),
+      })
+      .strict(),
+  })
+  args: GitHubCreatePullRequestArgs;
+
+  async execute(args: GitHubCreatePullRequestArgs, ctx: RunContext): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+
+    if (!accessToken) {
+      return {
+        data: {
+          error: 'unauthorized',
+          message: 'No valid GitHub token found. Please authenticate first.',
+        },
+      };
+    }
+
+    const requestBody: Record<string, unknown> = {
+      title: args.title,
+      head: args.head,
+      base: args.base,
+      draft: args.draft ?? false,
+    };
+
+    if (args.body) requestBody.body = args.body;
+
+    const url = `https://api.github.com/repos/${encodeURIComponent(args.owner)}/${encodeURIComponent(args.repo)}/pulls`;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(requestBody),
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      return {
+        data: {
+          error: '401',
+          message: 'GitHub token was rejected. Please re-authenticate.',
+        },
+      };
+    }
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      this.logger.error(`GitHub API error: ${response.status} ${errorBody}`);
+      return {
+        data: {
+          error: 'api_error',
+          message: `GitHub API error: ${response.statusText}`,
+        },
+      };
+    }
+
+    const pr = (await response.json()) as {
+      id: number;
+      number: number;
+      title: string;
+      html_url: string;
+      state: string;
+      draft: boolean;
+    };
+
+    return {
+      data: {
+        pullRequest: {
+          id: pr.id,
+          number: pr.number,
+          title: pr.title,
+          htmlUrl: pr.html_url,
+          state: pr.state,
+          draft: pr.draft,
+        },
+      },
+    };
+  }
+}

package/src/tools/pull-requests/github-get-pull-request.tool.ts

@@ -0,0 +1,128 @@
+import { Inject, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { OAuthTokenStore } from '@loopstack/oauth-module';
+
+export type GitHubGetPullRequestArgs = {
+  owner: string;
+  repo: string;
+  pullNumber: number;
+};
+
+@Tool({
+  config: {
+    description:
+      'Gets detailed information about a specific GitHub pull request. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubGetPullRequestTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubGetPullRequestTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        owner: z.string(),
+        repo: z.string(),
+        pullNumber: z.number(),
+      })
+      .strict(),
+  })
+  args: GitHubGetPullRequestArgs;
+
+  async execute(args: GitHubGetPullRequestArgs, ctx: RunContext): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+
+    if (!accessToken) {
+      return {
+        data: {
+          error: 'unauthorized',
+          message: 'No valid GitHub token found. Please authenticate first.',
+        },
+      };
+    }
+
+    const url = `https://api.github.com/repos/${encodeURIComponent(args.owner)}/${encodeURIComponent(args.repo)}/pulls/${args.pullNumber}`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      return {
+        data: {
+          error: '401',
+          message: 'GitHub token was rejected. Please re-authenticate.',
+        },
+      };
+    }
+
+    if (!response.ok) {
+      const body = await response.text();
+      this.logger.error(`GitHub API error: ${response.status} ${body}`);
+      return {
+        data: {
+          error: 'api_error',
+          message: `GitHub API error: ${response.statusText}`,
+        },
+      };
+    }
+
+    const pr = (await response.json()) as {
+      id: number;
+      number: number;
+      title: string;
+      body: string | null;
+      state: string;
+      user: { login: string };
+      head: { ref: string; sha: string };
+      base: { ref: string };
+      merged: boolean;
+      mergeable: boolean | null;
+      draft: boolean;
+      additions: number;
+      deletions: number;
+      changed_files: number;
+      created_at: string;
+      updated_at: string;
+      merged_at: string | null;
+      html_url: string;
+      comments: number;
+      review_comments: number;
+    };
+
+    return {
+      data: {
+        pullRequest: {
+          id: pr.id,
+          number: pr.number,
+          title: pr.title,
+          body: pr.body,
+          state: pr.state,
+          user: pr.user.login,
+          head: pr.head.ref,
+          headSha: pr.head.sha,
+          base: pr.base.ref,
+          merged: pr.merged,
+          mergeable: pr.mergeable,
+          draft: pr.draft,
+          additions: pr.additions,
+          deletions: pr.deletions,
+          changedFiles: pr.changed_files,
+          createdAt: pr.created_at,
+          updatedAt: pr.updated_at,
+          mergedAt: pr.merged_at,
+          htmlUrl: pr.html_url,
+          comments: pr.comments,
+          reviewComments: pr.review_comments,
+        },
+      },
+    };
+  }
+}

package/src/tools/pull-requests/github-list-pr-reviews.tool.ts

@@ -0,0 +1,99 @@
+import { Inject, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { OAuthTokenStore } from '@loopstack/oauth-module';
+
+export type GitHubListPrReviewsArgs = {
+  owner: string;
+  repo: string;
+  pullNumber: number;
+};
+
+@Tool({
+  config: {
+    description:
+      'Lists reviews on a GitHub pull request. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubListPrReviewsTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubListPrReviewsTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        owner: z.string(),
+        repo: z.string(),
+        pullNumber: z.number(),
+      })
+      .strict(),
+  })
+  args: GitHubListPrReviewsArgs;
+
+  async execute(args: GitHubListPrReviewsArgs, ctx: RunContext): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+
+    if (!accessToken) {
+      return {
+        data: {
+          error: 'unauthorized',
+          message: 'No valid GitHub token found. Please authenticate first.',
+        },
+      };
+    }
+
+    const url = `https://api.github.com/repos/${encodeURIComponent(args.owner)}/${encodeURIComponent(args.repo)}/pulls/${args.pullNumber}/reviews`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      return {
+        data: {
+          error: '401',
+          message: 'GitHub token was rejected. Please re-authenticate.',
+        },
+      };
+    }
+
+    if (!response.ok) {
+      const body = await response.text();
+      this.logger.error(`GitHub API error: ${response.status} ${body}`);
+      return {
+        data: {
+          error: 'api_error',
+          message: `GitHub API error: ${response.statusText}`,
+        },
+      };
+    }
+
+    const data = (await response.json()) as Array<{
+      id: number;
+      user: { login: string };
+      body: string;
+      state: string;
+      submitted_at: string;
+      html_url: string;
+    }>;
+
+    const reviews = data.map((review) => ({
+      id: review.id,
+      user: review.user.login,
+      body: review.body,
+      state: review.state,
+      submittedAt: review.submitted_at,
+      htmlUrl: review.html_url,
+    }));
+
+    return {
+      data: { reviews },
+    };
+  }
+}

package/src/tools/pull-requests/github-list-pull-requests.tool.ts

@@ -0,0 +1,124 @@
+import { Inject, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { OAuthTokenStore } from '@loopstack/oauth-module';
+
+export type GitHubListPullRequestsArgs = {
+  owner: string;
+  repo: string;
+  state?: string;
+  base?: string;
+  perPage?: number;
+  page?: number;
+};
+
+@Tool({
+  config: {
+    description:
+      'Lists pull requests for a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubListPullRequestsTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubListPullRequestsTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        owner: z.string(),
+        repo: z.string(),
+        state: z.enum(['open', 'closed', 'all']).default('open'),
+        base: z.string().optional(),
+        perPage: z.number().default(30),
+        page: z.number().default(1),
+      })
+      .strict(),
+  })
+  args: GitHubListPullRequestsArgs;
+
+  async execute(args: GitHubListPullRequestsArgs, ctx: RunContext): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+
+    if (!accessToken) {
+      return {
+        data: {
+          error: 'unauthorized',
+          message: 'No valid GitHub token found. Please authenticate first.',
+        },
+      };
+    }
+
+    const params = new URLSearchParams({
+      state: args.state ?? 'open',
+      per_page: String(args.perPage ?? 30),
+      page: String(args.page ?? 1),
+    });
+
+    if (args.base) params.set('base', args.base);
+
+    const url = `https://api.github.com/repos/${encodeURIComponent(args.owner)}/${encodeURIComponent(args.repo)}/pulls?${params.toString()}`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      return {
+        data: {
+          error: '401',
+          message: 'GitHub token was rejected. Please re-authenticate.',
+        },
+      };
+    }
+
+    if (!response.ok) {
+      const body = await response.text();
+      this.logger.error(`GitHub API error: ${response.status} ${body}`);
+      return {
+        data: {
+          error: 'api_error',
+          message: `GitHub API error: ${response.statusText}`,
+        },
+      };
+    }
+
+    const data = (await response.json()) as Array<{
+      id: number;
+      number: number;
+      title: string;
+      state: string;
+      user: { login: string };
+      head: { ref: string; sha: string };
+      base: { ref: string };
+      created_at: string;
+      updated_at: string;
+      html_url: string;
+      draft: boolean;
+    }>;
+
+    const pullRequests = data.map((pr) => ({
+      id: pr.id,
+      number: pr.number,
+      title: pr.title,
+      state: pr.state,
+      user: pr.user.login,
+      head: pr.head.ref,
+      headSha: pr.head.sha,
+      base: pr.base.ref,
+      createdAt: pr.created_at,
+      updatedAt: pr.updated_at,
+      htmlUrl: pr.html_url,
+      draft: pr.draft,
+    }));
+
+    return {
+      data: { pullRequests },
+    };
+  }
+}