@loopstack/github-module 0.1.0 → 0.2.0

package/src/tools/actions/github-trigger-workflow.tool.ts

@@ -1,43 +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 GitHubTriggerWorkflowArgs = {
-  owner: string;
-  repo: string;
-  workflowId: string;
-  ref: string;
-  inputs?: Record<string, string>;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    workflowId: z.string(),
+    ref: z.string(),
+    inputs: z.record(z.string(), z.string()).optional(),
+  })
+  .strict();
+
+export type GitHubTriggerWorkflowArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Triggers a GitHub Actions workflow dispatch event. Returns 204 No Content on success. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubTriggerWorkflowTool implements ToolInterface {
+export class GitHubTriggerWorkflowTool extends BaseTool {
   private readonly logger = new Logger(GitHubTriggerWorkflowTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        workflowId: z.string(),
-        ref: z.string(),
-        inputs: z.record(z.string(), z.string()).optional(),
-      })
-      .strict(),
-  })
-  args: GitHubTriggerWorkflowArgs;
-
-  async execute(args: GitHubTriggerWorkflowArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubTriggerWorkflowArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -67,7 +59,7 @@ export class GitHubTriggerWorkflowTool 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/content/github-create-or-update-file.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 GitHubCreateOrUpdateFileArgs = {
-  owner: string;
-  repo: string;
-  path: string;
-  content: string;
-  message: string;
-  sha?: string;
-  branch?: string;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    path: z.string(),
+    content: z.string(),
+    message: z.string(),
+    sha: z.string().optional(),
+    branch: z.string().optional(),
+  })
+  .strict();
+
+export type GitHubCreateOrUpdateFileArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Creates or updates a file in a GitHub repository. Content is provided as plain text and encoded to base64 before sending. To update an existing file, provide the sha of the file being replaced. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubCreateOrUpdateFileTool implements ToolInterface {
+export class GitHubCreateOrUpdateFileTool extends BaseTool {
   private readonly logger = new Logger(GitHubCreateOrUpdateFileTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        path: z.string(),
-        content: z.string(),
-        message: z.string(),
-        sha: z.string().optional(),
-        branch: z.string().optional(),
-      })
-      .strict(),
-  })
-  args: GitHubCreateOrUpdateFileArgs;
-
-  async execute(args: GitHubCreateOrUpdateFileArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubCreateOrUpdateFileArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -73,7 +63,7 @@ export class GitHubCreateOrUpdateFileTool 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/content/github-get-commit.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 GitHubGetCommitArgs = {
-  owner: string;
-  repo: string;
-  ref: string;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    ref: z.string(),
+  })
+  .strict();
+
+export type GitHubGetCommitArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Gets detailed information about a specific commit in a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubGetCommitTool implements ToolInterface {
+export class GitHubGetCommitTool extends BaseTool {
   private readonly logger = new Logger(GitHubGetCommitTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        ref: z.string(),
-      })
-      .strict(),
-  })
-  args: GitHubGetCommitArgs;
-
-  async execute(args: GitHubGetCommitArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubGetCommitArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -54,7 +48,7 @@ export class GitHubGetCommitTool 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/content/github-get-file-content.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 GitHubGetFileContentArgs = {
-  owner: string;
-  repo: string;
-  path: string;
-  ref?: string;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    path: z.string(),
+    ref: z.string().optional(),
+  })
+  .strict();
+
+export type GitHubGetFileContentArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Gets the content of a file from a GitHub repository. Decodes base64-encoded content from the API. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubGetFileContentTool implements ToolInterface {
+export class GitHubGetFileContentTool extends BaseTool {
   private readonly logger = new Logger(GitHubGetFileContentTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        path: z.string(),
-        ref: z.string().optional(),
-      })
-      .strict(),
-  })
-  args: GitHubGetFileContentArgs;
-
-  async execute(args: GitHubGetFileContentArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubGetFileContentArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -59,7 +52,7 @@ export class GitHubGetFileContentTool 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/content/github-list-directory.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 GitHubListDirectoryArgs = {
-  owner: string;
-  repo: string;
-  path?: string;
-  ref?: string;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    path: z.string().default(''),
+    ref: z.string().optional(),
+  })
+  .strict();
+
+export type GitHubListDirectoryArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Lists the contents of a directory in a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubListDirectoryTool implements ToolInterface {
+export class GitHubListDirectoryTool extends BaseTool {
   private readonly logger = new Logger(GitHubListDirectoryTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        path: z.string().default(''),
-        ref: z.string().optional(),
-      })
-      .strict(),
-  })
-  args: GitHubListDirectoryArgs;
-
-  async execute(args: GitHubListDirectoryArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubListDirectoryArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -60,7 +53,7 @@ export class GitHubListDirectoryTool 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/issues/github-create-issue-comment.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 GitHubCreateIssueCommentArgs = {
-  owner: string;
-  repo: string;
-  issueNumber: number;
-  body: string;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    issueNumber: z.number(),
+    body: z.string(),
+  })
+  .strict();
+
+export type GitHubCreateIssueCommentArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Creates a comment on a GitHub issue or pull request. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubCreateIssueCommentTool implements ToolInterface {
+export class GitHubCreateIssueCommentTool extends BaseTool {
   private readonly logger = new Logger(GitHubCreateIssueCommentTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        issueNumber: z.number(),
-        body: z.string(),
-      })
-      .strict(),
-  })
-  args: GitHubCreateIssueCommentArgs;
-
-  async execute(args: GitHubCreateIssueCommentArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubCreateIssueCommentArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -59,7 +52,7 @@ export class GitHubCreateIssueCommentTool 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/issues/github-create-issue.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 GitHubCreateIssueArgs = {
-  owner: string;
-  repo: string;
-  title: string;
-  body?: string;
-  labels?: string[];
-  assignees?: string[];
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    title: z.string(),
+    body: z.string().optional(),
+    labels: z.array(z.string()).optional(),
+    assignees: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export type GitHubCreateIssueArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Creates a new issue in a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubCreateIssueTool implements ToolInterface {
+export class GitHubCreateIssueTool extends BaseTool {
   private readonly logger = new Logger(GitHubCreateIssueTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        title: z.string(),
-        body: z.string().optional(),
-        labels: z.array(z.string()).optional(),
-        assignees: z.array(z.string()).optional(),
-      })
-      .strict(),
-  })
-  args: GitHubCreateIssueArgs;
-
-  async execute(args: GitHubCreateIssueArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubCreateIssueArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -71,7 +62,7 @@ export class GitHubCreateIssueTool 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/issues/github-get-issue.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 GitHubGetIssueArgs = {
-  owner: string;
-  repo: string;
-  issueNumber: number;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    issueNumber: z.number(),
+  })
+  .strict();
+
+export type GitHubGetIssueArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Gets detailed information about a specific GitHub issue. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubGetIssueTool implements ToolInterface {
+export class GitHubGetIssueTool extends BaseTool {
   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');
+  async call(args: GitHubGetIssueArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -54,7 +48,7 @@ export class GitHubGetIssueTool 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/issues/github-list-issues.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 GitHubListIssuesArgs = {
-  owner: string;
-  repo: string;
-  state?: string;
-  labels?: string;
-  assignee?: string;
-  perPage?: number;
-  page?: number;
-};
+const inputSchema = 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();
+
+export type GitHubListIssuesArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     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.',
   },
+  schema: inputSchema,
 })
-export class GitHubListIssuesTool implements ToolInterface {
+export class GitHubListIssuesTool extends BaseTool {
   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');
+  async call(args: GitHubListIssuesArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -71,7 +61,7 @@ export class GitHubListIssuesTool 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',