@loopstack/github-module 0.1.0 → 0.2.1

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',

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

@@ -1,43 +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 GitHubSearchIssuesArgs = {
-  query: string;
-  sort?: string;
-  perPage?: number;
-  page?: number;
-};
+const inputSchema = 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();
+
+export type GitHubSearchIssuesArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Searches for issues and pull requests across GitHub using the GitHub search syntax. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubSearchIssuesTool implements ToolInterface {
+export class GitHubSearchIssuesTool extends BaseTool {
   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');
+  async call(args: GitHubSearchIssuesArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -65,7 +58,7 @@ export class GitHubSearchIssuesTool 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-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 GitHubSearchReposArgs = {
-  query: string;
-  sort?: string;
-  perPage?: number;
-  page?: number;
-};
+const inputSchema = 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();
+
+export type GitHubSearchReposArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Searches for repositories on GitHub using the GitHub search syntax. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubSearchReposTool implements ToolInterface {
+export class GitHubSearchReposTool extends BaseTool {
   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');
+  async call(args: GitHubSearchReposArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -63,7 +56,7 @@ export class GitHubSearchReposTool 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/users/github-get-authenticated-user.tool.ts

@@ -1,29 +1,27 @@
 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 GitHubGetAuthenticatedUserArgs = Record<string, never>;
+const inputSchema = z.object({}).strict();
+
+export type GitHubGetAuthenticatedUserArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Gets the profile of the currently authenticated GitHub user. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubGetAuthenticatedUserTool implements ToolInterface {
+export class GitHubGetAuthenticatedUserTool extends BaseTool {
   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');
+  async call(_args: GitHubGetAuthenticatedUserArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -43,7 +41,7 @@ export class GitHubGetAuthenticatedUserTool 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/users/github-list-user-orgs.tool.ts

@@ -1,35 +1,31 @@
 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 GitHubListUserOrgsArgs = {
-  perPage?: number;
-};
+const inputSchema = z
+  .object({
+    perPage: z.number().default(30),
+  })
+  .strict();
+
+export type GitHubListUserOrgsArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Lists organizations for the authenticated GitHub user. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubListUserOrgsTool implements ToolInterface {
+export class GitHubListUserOrgsTool extends BaseTool {
   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');
+  async call(args: GitHubListUserOrgsArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -53,7 +49,7 @@ export class GitHubListUserOrgsTool 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',