@loopstack/github-module 0.1.0

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

@@ -0,0 +1,120 @@
+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 GitHubSearchIssuesArgs = {
+  query: string;
+  sort?: string;
+  perPage?: number;
+  page?: number;
+};
+
+@Tool({
+  config: {
+    description:
+      'Searches for issues and pull requests across GitHub using the GitHub search syntax. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubSearchIssuesTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubSearchIssuesTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        query: z.string(),
+        sort: z
+          .enum(['comments', 'reactions', 'reactions-+1', 'reactions--1', 'interactions', 'created', 'updated'])
+          .optional(),
+        perPage: z.number().default(30),
+        page: z.number().default(1),
+      })
+      .strict(),
+  })
+  args: GitHubSearchIssuesArgs;
+
+  async execute(args: GitHubSearchIssuesArgs, 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({
+      q: args.query,
+      per_page: String(args.perPage ?? 30),
+      page: String(args.page ?? 1),
+    });
+
+    if (args.sort) params.set('sort', args.sort);
+
+    const response = await fetch(`https://api.github.com/search/issues?${params.toString()}`, {
+      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 {
+      total_count: number;
+      items: Array<{
+        id: number;
+        number: number;
+        title: string;
+        state: string;
+        user: { login: string };
+        html_url: string;
+        repository_url: string;
+        created_at: string;
+        updated_at: string;
+        pull_request?: unknown;
+      }>;
+    };
+
+    const results = data.items.map((item) => ({
+      id: item.id,
+      number: item.number,
+      title: item.title,
+      state: item.state,
+      user: item.user.login,
+      htmlUrl: item.html_url,
+      createdAt: item.created_at,
+      updatedAt: item.updated_at,
+      isPullRequest: !!item.pull_request,
+    }));
+
+    return {
+      data: { totalCount: data.total_count, results },
+    };
+  }
+}

package/src/tools/search/github-search-repos.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 GitHubSearchReposArgs = {
+  query: string;
+  sort?: string;
+  perPage?: number;
+  page?: number;
+};
+
+@Tool({
+  config: {
+    description:
+      'Searches for repositories on GitHub using the GitHub search syntax. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubSearchReposTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubSearchReposTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        query: z.string(),
+        sort: z.enum(['stars', 'forks', 'help-wanted-issues', 'updated']).optional(),
+        perPage: z.number().default(30),
+        page: z.number().default(1),
+      })
+      .strict(),
+  })
+  args: GitHubSearchReposArgs;
+
+  async execute(args: GitHubSearchReposArgs, 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({
+      q: args.query,
+      per_page: String(args.perPage ?? 30),
+      page: String(args.page ?? 1),
+    });
+
+    if (args.sort) params.set('sort', args.sort);
+
+    const response = await fetch(`https://api.github.com/search/repositories?${params.toString()}`, {
+      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 {
+      total_count: number;
+      items: Array<{
+        id: number;
+        full_name: string;
+        description: string | null;
+        html_url: string;
+        language: string | null;
+        stargazers_count: number;
+        forks_count: number;
+        updated_at: string;
+      }>;
+    };
+
+    const results = data.items.map((item) => ({
+      id: item.id,
+      fullName: item.full_name,
+      description: item.description,
+      htmlUrl: item.html_url,
+      language: item.language,
+      stars: item.stargazers_count,
+      forks: item.forks_count,
+      updatedAt: item.updated_at,
+    }));
+
+    return {
+      data: { totalCount: data.total_count, results },
+    };
+  }
+}

package/src/tools/users/github-get-authenticated-user.tool.ts

@@ -0,0 +1,98 @@
+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 GitHubGetAuthenticatedUserArgs = Record<string, never>;
+
+@Tool({
+  config: {
+    description:
+      'Gets the profile of the currently authenticated GitHub user. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubGetAuthenticatedUserTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubGetAuthenticatedUserTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z.object({}).strict(),
+  })
+  args: GitHubGetAuthenticatedUserArgs;
+
+  async execute(_args: GitHubGetAuthenticatedUserArgs, 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 response = await fetch('https://api.github.com/user', {
+      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 user = (await response.json()) as {
+      id: number;
+      login: string;
+      name: string | null;
+      email: string | null;
+      avatar_url: string;
+      html_url: string;
+      bio: string | null;
+      public_repos: number;
+      followers: number;
+      following: number;
+      created_at: string;
+    };
+
+    return {
+      data: {
+        user: {
+          id: user.id,
+          login: user.login,
+          name: user.name,
+          email: user.email,
+          avatarUrl: user.avatar_url,
+          htmlUrl: user.html_url,
+          bio: user.bio,
+          publicRepos: user.public_repos,
+          followers: user.followers,
+          following: user.following,
+          createdAt: user.created_at,
+        },
+      },
+    };
+  }
+}

package/src/tools/users/github-list-user-orgs.tool.ts

@@ -0,0 +1,94 @@
+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 GitHubListUserOrgsArgs = {
+  perPage?: number;
+};
+
+@Tool({
+  config: {
+    description:
+      'Lists organizations for the authenticated GitHub user. Returns { error: "unauthorized" } if no valid token is available.',
+  },
+})
+export class GitHubListUserOrgsTool implements ToolInterface {
+  private readonly logger = new Logger(GitHubListUserOrgsTool.name);
+
+  @Inject()
+  private tokenStore: OAuthTokenStore;
+
+  @Input({
+    schema: z
+      .object({
+        perPage: z.number().default(30),
+      })
+      .strict(),
+  })
+  args: GitHubListUserOrgsArgs;
+
+  async execute(args: GitHubListUserOrgsArgs, 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({
+      per_page: String(args.perPage ?? 30),
+    });
+
+    const response = await fetch(`https://api.github.com/user/orgs?${params.toString()}`, {
+      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;
+      login: string;
+      description: string | null;
+      avatar_url: string;
+    }>;
+
+    const orgs = data.map((org) => ({
+      id: org.id,
+      login: org.login,
+      description: org.description,
+      avatarUrl: org.avatar_url,
+    }));
+
+    return {
+      data: { orgs },
+    };
+  }
+}