@loopstack/github-module 0.1.0 → 0.2.0

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

@@ -1,47 +1,37 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, 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;
-};
+const inputSchema = 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();
+
+export type GitHubCreatePullRequestArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Creates a new pull request in a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubCreatePullRequestTool implements ToolInterface {
+export class GitHubCreatePullRequestTool extends BaseTool {
   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');
+  async call(args: GitHubCreatePullRequestArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -74,7 +64,7 @@ export class GitHubCreatePullRequestTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

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

@@ -1,39 +1,33 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
 import { OAuthTokenStore } from '@loopstack/oauth-module';
 
-export type GitHubGetPullRequestArgs = {
-  owner: string;
-  repo: string;
-  pullNumber: number;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    pullNumber: z.number(),
+  })
+  .strict();
+
+export type GitHubGetPullRequestArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Gets detailed information about a specific GitHub pull request. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubGetPullRequestTool implements ToolInterface {
+export class GitHubGetPullRequestTool extends BaseTool {
   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');
+  async call(args: GitHubGetPullRequestArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -54,7 +48,7 @@ export class GitHubGetPullRequestTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

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

@@ -1,39 +1,33 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
 import { OAuthTokenStore } from '@loopstack/oauth-module';
 
-export type GitHubListPrReviewsArgs = {
-  owner: string;
-  repo: string;
-  pullNumber: number;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    pullNumber: z.number(),
+  })
+  .strict();
+
+export type GitHubListPrReviewsArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Lists reviews on a GitHub pull request. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubListPrReviewsTool implements ToolInterface {
+export class GitHubListPrReviewsTool extends BaseTool {
   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');
+  async call(args: GitHubListPrReviewsArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -54,7 +48,7 @@ export class GitHubListPrReviewsTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

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

@@ -1,45 +1,36 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, 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;
-};
+const inputSchema = 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();
+
+export type GitHubListPullRequestsArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Lists pull requests for a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubListPullRequestsTool implements ToolInterface {
+export class GitHubListPullRequestsTool extends BaseTool {
   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');
+  async call(args: GitHubListPullRequestsArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -68,7 +59,7 @@ export class GitHubListPullRequestsTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

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

@@ -1,44 +1,35 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
 import { OAuthTokenStore } from '@loopstack/oauth-module';
 
-export type GitHubMergePullRequestArgs = {
-  owner: string;
-  repo: string;
-  pullNumber: number;
-  mergeMethod?: string;
-  commitTitle?: string;
-  commitMessage?: string;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    pullNumber: z.number(),
+    mergeMethod: z.enum(['merge', 'squash', 'rebase']).default('merge'),
+    commitTitle: z.string().optional(),
+    commitMessage: z.string().optional(),
+  })
+  .strict();
+
+export type GitHubMergePullRequestArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description: 'Merges a GitHub pull request. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubMergePullRequestTool implements ToolInterface {
+export class GitHubMergePullRequestTool extends BaseTool {
   private readonly logger = new Logger(GitHubMergePullRequestTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        pullNumber: z.number(),
-        mergeMethod: z.enum(['merge', 'squash', 'rebase']).default('merge'),
-        commitTitle: z.string().optional(),
-        commitMessage: z.string().optional(),
-      })
-      .strict(),
-  })
-  args: GitHubMergePullRequestArgs;
-
-  async execute(args: GitHubMergePullRequestArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubMergePullRequestArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -69,7 +60,7 @@ export class GitHubMergePullRequestTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

package/src/tools/repos/github-create-repo.tool.ts

@@ -1,41 +1,34 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
 import { OAuthTokenStore } from '@loopstack/oauth-module';
 
-export type GitHubCreateRepoArgs = {
-  name: string;
-  description?: string;
-  private?: boolean;
-  autoInit?: boolean;
-};
+const inputSchema = z
+  .object({
+    name: z.string(),
+    description: z.string().optional(),
+    private: z.boolean().default(false),
+    autoInit: z.boolean().default(false),
+  })
+  .strict();
+
+export type GitHubCreateRepoArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Creates a new GitHub repository for the authenticated user. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubCreateRepoTool implements ToolInterface {
+export class GitHubCreateRepoTool extends BaseTool {
   private readonly logger = new Logger(GitHubCreateRepoTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        name: z.string(),
-        description: z.string().optional(),
-        private: z.boolean().default(false),
-        autoInit: z.boolean().default(false),
-      })
-      .strict(),
-  })
-  args: GitHubCreateRepoArgs;
-
-  async execute(args: GitHubCreateRepoArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubCreateRepoArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -66,7 +59,7 @@ export class GitHubCreateRepoTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

package/src/tools/repos/github-get-repo.tool.ts

@@ -1,37 +1,32 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
 import { OAuthTokenStore } from '@loopstack/oauth-module';
 
-export type GitHubGetRepoArgs = {
-  owner: string;
-  repo: string;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+  })
+  .strict();
+
+export type GitHubGetRepoArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Gets detailed information about a specific GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubGetRepoTool implements ToolInterface {
+export class GitHubGetRepoTool extends BaseTool {
   private readonly logger = new Logger(GitHubGetRepoTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-      })
-      .strict(),
-  })
-  args: GitHubGetRepoArgs;
-
-  async execute(args: GitHubGetRepoArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubGetRepoArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -54,7 +49,7 @@ export class GitHubGetRepoTool implements ToolInterface {
     );
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

package/src/tools/repos/github-list-branches.tool.ts

@@ -1,39 +1,33 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
 import { OAuthTokenStore } from '@loopstack/oauth-module';
 
-export type GitHubListBranchesArgs = {
-  owner: string;
-  repo: string;
-  perPage?: number;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    perPage: z.number().default(30),
+  })
+  .strict();
+
+export type GitHubListBranchesArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Lists branches for a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubListBranchesTool implements ToolInterface {
+export class GitHubListBranchesTool extends BaseTool {
   private readonly logger = new Logger(GitHubListBranchesTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        perPage: z.number().default(30),
-      })
-      .strict(),
-  })
-  args: GitHubListBranchesArgs;
-
-  async execute(args: GitHubListBranchesArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubListBranchesArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -58,7 +52,7 @@ export class GitHubListBranchesTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

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

@@ -1,41 +1,34 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
 import { OAuthTokenStore } from '@loopstack/oauth-module';
 
-export type GitHubListReposArgs = {
-  visibility?: string;
-  sort?: string;
-  perPage?: number;
-  page?: number;
-};
+const inputSchema = z
+  .object({
+    visibility: z.enum(['all', 'public', 'private']).default('all'),
+    sort: z.enum(['created', 'updated', 'pushed', 'full_name']).default('updated'),
+    perPage: z.number().default(30),
+    page: z.number().default(1),
+  })
+  .strict();
+
+export type GitHubListReposArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Lists repositories for the authenticated GitHub user. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubListReposTool implements ToolInterface {
+export class GitHubListReposTool extends BaseTool {
   private readonly logger = new Logger(GitHubListReposTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        visibility: z.enum(['all', 'public', 'private']).default('all'),
-        sort: z.enum(['created', 'updated', 'pushed', 'full_name']).default('updated'),
-        perPage: z.number().default(30),
-        page: z.number().default(1),
-      })
-      .strict(),
-  })
-  args: GitHubListReposArgs;
-
-  async execute(args: GitHubListReposArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubListReposArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -62,7 +55,7 @@ export class GitHubListReposTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',

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

@@ -1,39 +1,33 @@
 import { Inject, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import { Input, RunContext, Tool, ToolInterface, ToolResult } from '@loopstack/common';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
 import { OAuthTokenStore } from '@loopstack/oauth-module';
 
-export type GitHubSearchCodeArgs = {
-  query: string;
-  perPage?: number;
-  page?: number;
-};
+const inputSchema = z
+  .object({
+    query: z.string(),
+    perPage: z.number().default(30),
+    page: z.number().default(1),
+  })
+  .strict();
+
+export type GitHubSearchCodeArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Searches for code across GitHub repositories using the GitHub search syntax. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubSearchCodeTool implements ToolInterface {
+export class GitHubSearchCodeTool extends BaseTool {
   private readonly logger = new Logger(GitHubSearchCodeTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        query: z.string(),
-        perPage: z.number().default(30),
-        page: z.number().default(1),
-      })
-      .strict(),
-  })
-  args: GitHubSearchCodeArgs;
-
-  async execute(args: GitHubSearchCodeArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubSearchCodeArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -59,7 +53,7 @@ export class GitHubSearchCodeTool implements ToolInterface {
     });
 
     if (response.status === 401 || response.status === 403) {
-      this.logger.warn(`GitHub API returned ${response.status} for user ${ctx.userId}`);
+      this.logger.warn(`GitHub API returned ${response.status} for user ${this.ctx.context.userId}`);
       return {
         data: {
           error: '401',