@loopstack/github-module 0.1.0 → 0.2.1

package/src/tools/actions/github-get-workflow-run.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 GitHubGetWorkflowRunArgs = {
-  owner: string;
-  repo: string;
-  runId: number;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    runId: z.number(),
+  })
+  .strict();
+
+export type GitHubGetWorkflowRunArgs = z.infer<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Gets detailed information about a specific GitHub Actions workflow run. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubGetWorkflowRunTool implements ToolInterface {
+export class GitHubGetWorkflowRunTool extends BaseTool {
   private readonly logger = new Logger(GitHubGetWorkflowRunTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        runId: z.number(),
-      })
-      .strict(),
-  })
-  args: GitHubGetWorkflowRunArgs;
-
-  async execute(args: GitHubGetWorkflowRunArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubGetWorkflowRunArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -54,7 +48,7 @@ export class GitHubGetWorkflowRunTool 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/actions/github-list-workflow-runs.tool.ts

@@ -1,62 +1,53 @@
 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 GitHubListWorkflowRunsArgs = {
-  owner: string;
-  repo: string;
-  branch?: string;
-  status?: string;
-  perPage?: number;
-  page?: number;
-};
+const inputSchema = z
+  .object({
+    owner: z.string(),
+    repo: z.string(),
+    branch: z.string().optional(),
+    status: z
+      .enum([
+        'completed',
+        'action_required',
+        'cancelled',
+        'failure',
+        'neutral',
+        'skipped',
+        'stale',
+        'success',
+        'timed_out',
+        'in_progress',
+        'queued',
+        'requested',
+        'waiting',
+        'pending',
+      ])
+      .optional(),
+    perPage: z.number().default(30),
+    page: z.number().default(1),
+  })
+  .strict();
+
+export type GitHubListWorkflowRunsArgs = z.input<typeof inputSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Lists workflow runs for a GitHub repository. Returns { error: "unauthorized" } if no valid token is available.',
   },
+  schema: inputSchema,
 })
-export class GitHubListWorkflowRunsTool implements ToolInterface {
+export class GitHubListWorkflowRunsTool extends BaseTool {
   private readonly logger = new Logger(GitHubListWorkflowRunsTool.name);
 
   @Inject()
   private tokenStore: OAuthTokenStore;
 
-  @Input({
-    schema: z
-      .object({
-        owner: z.string(),
-        repo: z.string(),
-        branch: z.string().optional(),
-        status: z
-          .enum([
-            'completed',
-            'action_required',
-            'cancelled',
-            'failure',
-            'neutral',
-            'skipped',
-            'stale',
-            'success',
-            'timed_out',
-            'in_progress',
-            'queued',
-            'requested',
-            'waiting',
-            'pending',
-          ])
-          .optional(),
-        perPage: z.number().default(30),
-        page: z.number().default(1),
-      })
-      .strict(),
-  })
-  args: GitHubListWorkflowRunsArgs;
-
-  async execute(args: GitHubListWorkflowRunsArgs, ctx: RunContext): Promise<ToolResult> {
-    const accessToken = await this.tokenStore.getValidAccessToken(ctx.userId, 'github');
+  async call(args: GitHubListWorkflowRunsArgs): Promise<ToolResult> {
+    const accessToken = await this.tokenStore.getValidAccessToken(this.ctx.context.userId, 'github');
 
     if (!accessToken) {
       return {
@@ -85,7 +76,7 @@ export class GitHubListWorkflowRunsTool 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/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',