@meetopenbot/github 0.0.1

package/README.md

@@ -0,0 +1,53 @@
+# GitHub OpenBot Plugin
+
+This plugin lets OpenBot interact with your GitHub account, enabling you to browse repositories, manage issues, and work with pull requests through natural language or direct tool calls.
+
+## Features
+
+- **List Repositories**: View repositories for the authenticated user.
+- **Get Repository**: Get detailed information about a repository.
+- **List Issues**: See open or closed issues for a repository.
+- **Create Issue**: Open a new issue.
+- **List Pull Requests**: See pull requests for a repository.
+- **Get Pull Request**: Get details about a specific pull request.
+- **Create Pull Request**: Open a new pull request.
+- **Natural Language Support**: Ask the agent about your repos and it will summarize results.
+
+## Configuration
+
+To use this plugin, you need a GitHub Personal Access Token. You can create one in your [GitHub Developer Settings](https://github.com/settings/tokens) with `repo` scope.
+
+### Config Schema
+
+- `githubToken` (Required): Your GitHub Personal Access Token.
+- `openaiApiKey` (Optional): OpenAI API key for natural language support (can also be set via environment).
+
+## Usage
+
+### Natural Language
+
+You can ask things like:
+
+- "What repositories do I have on GitHub?"
+- "Show me the open issues for owner/repo"
+- "Create an issue in owner/repo titled 'Fix login bug'"
+- "List the pull requests for owner/repo"
+
+### Tools
+
+The plugin provides the following tools:
+
+- `list_repos`: List repositories for the authenticated user.
+- `get_repo`: Get repository details.
+- `list_issues`: List issues for a repository.
+- `create_issue`: Create a new issue.
+- `list_pull_requests`: List pull requests for a repository.
+- `get_pull_request`: Get pull request details.
+- `create_pull_request`: Create a new pull request.
+
+## Installation
+
+1. Clone this repository into your OpenBot plugins directory.
+2. Run `npm install`.
+3. Run `npm run build`.
+4. Configure the plugin in your `AGENT.md` or via the OpenBot UI.

package/dist/index.js

@@ -0,0 +1,384 @@
+import { definePlugin, shouldHandleInvoke, agentOutput, uiWidget, } from '@meetopenbot/plugin-sdk';
+import { Octokit } from '@octokit/rest';
+import { generateText, stepCountIs, tool } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { z } from 'zod';
+const listReposSchema = z.object({
+    limit: z.number().optional().describe('Maximum number of repositories to return'),
+    visibility: z.enum(['all', 'public', 'private']).optional().describe('Filter by repository visibility'),
+    sort: z.enum(['created', 'updated', 'pushed', 'full_name']).optional().describe('How to sort the repositories'),
+});
+const getRepoSchema = z.object({
+    owner: z.string().describe('The owner of the repository (user or organization)'),
+    repo: z.string().describe('The name of the repository'),
+});
+const createRepoSchema = z.object({
+    name: z.string().describe('The name of the repository'),
+    org: z.string().optional().describe('The organization to create the repository in. If not provided, it will be created for the authenticated user.'),
+    description: z.string().optional().describe('A short description of the repository'),
+    private: z.boolean().optional().describe('Whether the repository is private'),
+    autoInit: z.boolean().optional().describe('Whether to create an initial commit with an empty README'),
+});
+export default definePlugin({
+    id: 'github',
+    name: 'GitHub',
+    description: 'Manage your GitHub repositories',
+    configSchema: {
+        type: 'object',
+        properties: {
+            githubToken: {
+                type: 'string',
+                description: 'GitHub Personal Access Token',
+                format: 'password',
+            },
+            openaiApiKey: {
+                type: 'string',
+                description: 'OpenAI API Key (optional if provided via environment)',
+                format: 'password',
+            },
+        },
+        required: ['githubToken'],
+    },
+    toolDefinitions: {
+        list_repos: {
+            description: 'List repositories for the authenticated user',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    limit: { type: 'number', description: 'Maximum number of repositories to return' },
+                    visibility: { type: 'string', enum: ['all', 'public', 'private'], description: 'Filter by repository visibility' },
+                    sort: { type: 'string', enum: ['created', 'updated', 'pushed', 'full_name'], description: 'How to sort the repositories' },
+                },
+            },
+        },
+        get_repo: {
+            description: 'Get details of a specific repository',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    owner: { type: 'string', description: 'The owner of the repository' },
+                    repo: { type: 'string', description: 'The name of the repository' },
+                },
+                required: ['owner', 'repo'],
+            },
+        },
+        create_repo: {
+            description: 'Create a new repository',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'The name of the repository' },
+                    org: { type: 'string', description: 'The organization to create the repository in' },
+                    description: { type: 'string', description: 'A short description of the repository' },
+                    private: { type: 'boolean', description: 'Whether the repository is private' },
+                    autoInit: { type: 'boolean', description: 'Whether to create an initial commit with an empty README' },
+                },
+                required: ['name'],
+            },
+        },
+    },
+    factory: (context) => {
+        const getCredentials = async () => {
+            const config = context.config;
+            const env = process.env;
+            const variables = await context.storage.getVariables();
+            const getVal = (key, envKey) => {
+                if (config[key])
+                    return config[key];
+                if (env[envKey])
+                    return env[envKey];
+                const v = variables[envKey];
+                return typeof v === 'string' ? v : v?.value;
+            };
+            return {
+                githubToken: config.githubToken,
+                openaiApiKey: getVal('openaiApiKey', 'OPENAI_API_KEY'),
+            };
+        };
+        const getOctokit = (githubToken) => {
+            return new Octokit({
+                auth: githubToken,
+                headers: {
+                    'X-GitHub-Api-Version': '2022-11-28',
+                },
+            });
+        };
+        return (builder) => {
+            // Handle agent:invoke for natural language queries
+            builder.on('agent:invoke', async function* (event) {
+                if (!shouldHandleInvoke(event, context.agentId))
+                    return;
+                const userMessage = event.data?.content || '';
+                const threadId = event.meta?.threadId;
+                if (!userMessage)
+                    return;
+                const { githubToken, openaiApiKey } = await getCredentials();
+                if (!openaiApiKey) {
+                    yield agentOutput({
+                        agentId: context.agentId,
+                        content: 'I need an OpenAI API key to help you manage GitHub. Please provide it below:',
+                        threadId,
+                    });
+                    yield uiWidget({
+                        agentId: context.agentId,
+                        threadId,
+                        widget: {
+                            kind: 'form',
+                            widgetId: 'github-config-form',
+                            title: 'OpenAI Configuration',
+                            description: 'Enter your OpenAI API key to get started.',
+                            fields: [
+                                {
+                                    id: 'openaiApiKey',
+                                    label: 'OpenAI API Key',
+                                    type: 'text',
+                                    placeholder: 'sk-...',
+                                    required: true,
+                                },
+                            ],
+                            submitLabel: 'Save Configuration',
+                        },
+                    });
+                    return;
+                }
+                const octokit = getOctokit(githubToken);
+                const openai = createOpenAI({ apiKey: openaiApiKey });
+                try {
+                    const { text, steps } = await generateText({
+                        model: openai('gpt-4o'),
+                        stopWhen: stepCountIs(5),
+                        system: `You are a GitHub management assistant. Help users manage their repositories.
+- Use list_repos to see the authenticated user's repositories.
+- Use get_repo to get details about a repository.
+- Use create_repo to create a new repository.
+When a tool requires an owner and repo, parse them from the "owner/repo" format the user provides.
+If a tool returns an error, explain it to the user or try an alternative approach if appropriate.
+Be concise and helpful.`,
+                        prompt: userMessage,
+                        tools: {
+                            list_repos: tool({
+                                description: 'List repositories for the authenticated user',
+                                inputSchema: listReposSchema,
+                                execute: async ({ limit, visibility, sort }) => {
+                                    try {
+                                        const result = await octokit.repos.listForAuthenticatedUser({
+                                            per_page: limit || 20,
+                                            visibility: visibility || 'all',
+                                            sort: sort || 'updated',
+                                        });
+                                        return result.data;
+                                    }
+                                    catch (error) {
+                                        return { error: error.message, status: error.status };
+                                    }
+                                },
+                            }),
+                            get_repo: tool({
+                                description: 'Get details of a specific repository',
+                                inputSchema: getRepoSchema,
+                                execute: async ({ owner, repo }) => {
+                                    try {
+                                        const result = await octokit.repos.get({ owner, repo });
+                                        return result.data;
+                                    }
+                                    catch (error) {
+                                        return { error: error.message, status: error.status };
+                                    }
+                                },
+                            }),
+                            create_repo: tool({
+                                description: 'Create a new repository',
+                                inputSchema: createRepoSchema,
+                                execute: async ({ name, org, description, private: isPrivate, autoInit }) => {
+                                    try {
+                                        const params = {
+                                            name,
+                                            description,
+                                            private: isPrivate,
+                                            auto_init: autoInit,
+                                        };
+                                        const result = org
+                                            ? await octokit.repos.createInOrg({ ...params, org })
+                                            : await octokit.repos.createForAuthenticatedUser(params);
+                                        return result.data;
+                                    }
+                                    catch (error) {
+                                        return {
+                                            error: error.message,
+                                            status: error.status,
+                                            details: error.response?.data,
+                                        };
+                                    }
+                                },
+                            }),
+                        },
+                    });
+                    if (text.trim()) {
+                        yield agentOutput({
+                            agentId: context.agentId,
+                            content: text,
+                            threadId,
+                        });
+                    }
+                    for (const step of steps) {
+                        for (const toolResult of step.toolResults) {
+                            if (toolResult.toolName === 'list_repos') {
+                                const repos = toolResult.output;
+                                yield uiWidget({
+                                    agentId: context.agentId,
+                                    threadId,
+                                    widget: {
+                                        kind: 'list',
+                                        title: 'GitHub Repositories',
+                                        items: (repos || []).map((r) => ({
+                                            id: String(r.id),
+                                            label: r.full_name,
+                                            description: r.description || (r.private ? 'Private' : 'Public'),
+                                            status: 'done',
+                                        })),
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    yield agentOutput({
+                        agentId: context.agentId,
+                        content: `I encountered an error: ${error.message}`,
+                        threadId,
+                    });
+                }
+            });
+            builder.on('client:ui:widget:response', async function* (event) {
+                if (event.data?.widgetId !== 'github-config-form')
+                    return;
+                const { openaiApiKey } = event.data.values || {};
+                if (openaiApiKey) {
+                    await context.storage.createVariable({
+                        key: 'OPENAI_API_KEY',
+                        value: openaiApiKey,
+                        secret: true,
+                    });
+                    yield agentOutput({
+                        agentId: context.agentId,
+                        content: "OpenAI API key saved! I'm now ready to help you with GitHub.",
+                        threadId: event.meta?.threadId,
+                    });
+                }
+            });
+            // Handle tool calls
+            builder.on('action:list_repos', async function* (event) {
+                const { githubToken } = await getCredentials();
+                const octokit = getOctokit(githubToken);
+                const { limit, visibility, sort } = (event.data || {});
+                try {
+                    const result = await octokit.repos.listForAuthenticatedUser({
+                        per_page: limit || 20,
+                        visibility: visibility || 'all',
+                        sort: sort || 'updated',
+                    });
+                    yield uiWidget({
+                        agentId: context.agentId,
+                        threadId: event.meta?.threadId,
+                        widget: {
+                            kind: 'list',
+                            title: 'GitHub Repositories',
+                            items: result.data.map((r) => ({
+                                id: String(r.id),
+                                label: r.full_name,
+                                description: r.description || (r.private ? 'Private' : 'Public'),
+                                status: 'done',
+                            })),
+                        },
+                    });
+                    yield {
+                        type: 'action:list_repos:result',
+                        data: {
+                            ...result.data,
+                            output: `Successfully listed ${result.data.length} repositories.`,
+                        },
+                        meta: event.meta,
+                    };
+                }
+                catch (error) {
+                    yield {
+                        type: 'action:list_repos:result',
+                        data: {
+                            error: error.message,
+                            status: error.status,
+                            details: error.response?.data,
+                            output: `Failed to list repositories: ${error.message}`,
+                        },
+                        meta: event.meta,
+                    };
+                }
+            });
+            builder.on('action:get_repo', async function* (event) {
+                const { githubToken } = await getCredentials();
+                const octokit = getOctokit(githubToken);
+                const { owner, repo } = (event.data || {});
+                try {
+                    const result = await octokit.repos.get({ owner, repo });
+                    yield {
+                        type: 'action:get_repo:result',
+                        data: {
+                            ...result.data,
+                            output: `Successfully retrieved details for ${owner}/${repo}.`,
+                        },
+                        meta: event.meta,
+                    };
+                }
+                catch (error) {
+                    yield {
+                        type: 'action:get_repo:result',
+                        data: {
+                            error: error.message,
+                            status: error.status,
+                            details: error.response?.data,
+                            output: `Failed to get repository ${owner}/${repo}: ${error.message}`,
+                        },
+                        meta: event.meta,
+                    };
+                }
+            });
+            builder.on('action:create_repo', async function* (event) {
+                console.log('action:create_repo', event);
+                const { githubToken } = await getCredentials();
+                const octokit = getOctokit(githubToken);
+                const { name, org, description, private: isPrivate, autoInit } = (event.data || {});
+                try {
+                    const params = {
+                        name,
+                        description,
+                        private: isPrivate,
+                        auto_init: autoInit,
+                    };
+                    const result = org
+                        ? await octokit.repos.createInOrg({ ...params, org })
+                        : await octokit.repos.createForAuthenticatedUser(params);
+                    yield {
+                        type: 'action:create_repo:result',
+                        data: {
+                            ...result.data,
+                            output: `Successfully created repository ${result.data.full_name}.`,
+                        },
+                        meta: event.meta,
+                    };
+                }
+                catch (error) {
+                    yield {
+                        type: 'action:create_repo:result',
+                        data: {
+                            error: error.message,
+                            status: error.status,
+                            details: error.response?.data,
+                            output: `Failed to create repository ${name}: ${error.message}`,
+                        },
+                        meta: event.meta,
+                    };
+                }
+            });
+        };
+    },
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@meetopenbot/github",
+  "version": "0.0.1",
+  "description": "Manage your GitHub repositories, issues, and pull requests from OpenBot",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^3.0.64",
+    "@meetopenbot/plugin-sdk": "^0.1.2",
+    "@octokit/rest": "^22.0.0",
+    "ai": "^6.0.185",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,418 @@
+import {
+  definePlugin,
+  shouldHandleInvoke,
+  agentOutput,
+  uiWidget,
+  type ToolActionEvent,
+} from '@meetopenbot/plugin-sdk';
+import { Octokit } from '@octokit/rest';
+import { generateText, stepCountIs, tool } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { z } from 'zod';
+
+const listReposSchema = z.object({
+  limit: z.number().optional().describe('Maximum number of repositories to return'),
+  visibility: z.enum(['all', 'public', 'private']).optional().describe('Filter by repository visibility'),
+  sort: z.enum(['created', 'updated', 'pushed', 'full_name']).optional().describe('How to sort the repositories'),
+});
+
+const getRepoSchema = z.object({
+  owner: z.string().describe('The owner of the repository (user or organization)'),
+  repo: z.string().describe('The name of the repository'),
+});
+
+const createRepoSchema = z.object({
+  name: z.string().describe('The name of the repository'),
+  org: z.string().optional().describe('The organization to create the repository in. If not provided, it will be created for the authenticated user.'),
+  description: z.string().optional().describe('A short description of the repository'),
+  private: z.boolean().optional().describe('Whether the repository is private'),
+  autoInit: z.boolean().optional().describe('Whether to create an initial commit with an empty README'),
+});
+
+export default definePlugin({
+  id: 'github',
+  name: 'GitHub',
+  description: 'Manage your GitHub repositories',
+  configSchema: {
+    type: 'object',
+    properties: {
+      githubToken: {
+        type: 'string',
+        description: 'GitHub Personal Access Token',
+        format: 'password',
+      },
+      openaiApiKey: {
+        type: 'string',
+        description: 'OpenAI API Key (optional if provided via environment)',
+        format: 'password',
+      },
+    },
+    required: ['githubToken'],
+  },
+  toolDefinitions: {
+    list_repos: {
+      description: 'List repositories for the authenticated user',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          limit: { type: 'number', description: 'Maximum number of repositories to return' },
+          visibility: { type: 'string', enum: ['all', 'public', 'private'], description: 'Filter by repository visibility' },
+          sort: { type: 'string', enum: ['created', 'updated', 'pushed', 'full_name'], description: 'How to sort the repositories' },
+        },
+      },
+    },
+    get_repo: {
+      description: 'Get details of a specific repository',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          owner: { type: 'string', description: 'The owner of the repository' },
+          repo: { type: 'string', description: 'The name of the repository' },
+        },
+        required: ['owner', 'repo'],
+      },
+    },
+    create_repo: {
+      description: 'Create a new repository',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'The name of the repository' },
+          org: { type: 'string', description: 'The organization to create the repository in' },
+          description: { type: 'string', description: 'A short description of the repository' },
+          private: { type: 'boolean', description: 'Whether the repository is private' },
+          autoInit: { type: 'boolean', description: 'Whether to create an initial commit with an empty README' },
+        },
+        required: ['name'],
+      },
+    },
+  },
+  factory: (context) => {
+    const getCredentials = async () => {
+      const config = context.config as { githubToken: string; openaiApiKey?: string };
+      const env = process.env;
+      const variables = await context.storage.getVariables();
+
+      const getVal = (key: string, envKey: string) => {
+        if (config[key as keyof typeof config]) return config[key as keyof typeof config] as string;
+        if (env[envKey]) return env[envKey] as string;
+        const v = variables[envKey];
+        return typeof v === 'string' ? v : v?.value;
+      };
+
+      return {
+        githubToken: config.githubToken,
+        openaiApiKey: getVal('openaiApiKey', 'OPENAI_API_KEY'),
+      };
+    };
+
+    const getOctokit = (githubToken: string) => {
+      return new Octokit({
+        auth: githubToken,
+        headers: {
+          'X-GitHub-Api-Version': '2022-11-28',
+        },
+      });
+    };
+
+    return (builder) => {
+      // Handle agent:invoke for natural language queries
+      builder.on('agent:invoke', async function* (event) {
+        if (!shouldHandleInvoke(event, context.agentId)) return;
+
+        const userMessage = event.data?.content || '';
+        const threadId = event.meta?.threadId;
+
+        if (!userMessage) return;
+
+        const { githubToken, openaiApiKey } = await getCredentials();
+
+        if (!openaiApiKey) {
+          yield agentOutput({
+            agentId: context.agentId,
+            content: 'I need an OpenAI API key to help you manage GitHub. Please provide it below:',
+            threadId,
+          });
+
+          yield uiWidget({
+            agentId: context.agentId,
+            threadId,
+            widget: {
+              kind: 'form',
+              widgetId: 'github-config-form',
+              title: 'OpenAI Configuration',
+              description: 'Enter your OpenAI API key to get started.',
+              fields: [
+                {
+                  id: 'openaiApiKey',
+                  label: 'OpenAI API Key',
+                  type: 'text',
+                  placeholder: 'sk-...',
+                  required: true,
+                },
+              ],
+              submitLabel: 'Save Configuration',
+            },
+          });
+          return;
+        }
+
+        const octokit = getOctokit(githubToken);
+        const openai = createOpenAI({ apiKey: openaiApiKey });
+
+        try {
+          const { text, steps } = await generateText({
+            model: openai('gpt-4o'),
+            stopWhen: stepCountIs(5),
+            system: `You are a GitHub management assistant. Help users manage their repositories.
+- Use list_repos to see the authenticated user's repositories.
+- Use get_repo to get details about a repository.
+- Use create_repo to create a new repository.
+When a tool requires an owner and repo, parse them from the "owner/repo" format the user provides.
+If a tool returns an error, explain it to the user or try an alternative approach if appropriate.
+Be concise and helpful.`,
+            prompt: userMessage,
+            tools: {
+              list_repos: tool({
+                description: 'List repositories for the authenticated user',
+                inputSchema: listReposSchema,
+                execute: async ({ limit, visibility, sort }: z.infer<typeof listReposSchema>) => {
+                  try {
+                    const result = await octokit.repos.listForAuthenticatedUser({
+                      per_page: limit || 20,
+                      visibility: visibility || 'all',
+                      sort: sort || 'updated',
+                    });
+                    return result.data;
+                  } catch (error: any) {
+                    return { error: error.message, status: error.status };
+                  }
+                },
+              }),
+              get_repo: tool({
+                description: 'Get details of a specific repository',
+                inputSchema: getRepoSchema,
+                execute: async ({ owner, repo }: z.infer<typeof getRepoSchema>) => {
+                  try {
+                    const result = await octokit.repos.get({ owner, repo });
+                    return result.data;
+                  } catch (error: any) {
+                    return { error: error.message, status: error.status };
+                  }
+                },
+              }),
+              create_repo: tool({
+                description: 'Create a new repository',
+                inputSchema: createRepoSchema,
+                execute: async ({ name, org, description, private: isPrivate, autoInit }: z.infer<typeof createRepoSchema>) => {
+                  try {
+                    const params = {
+                      name,
+                      description,
+                      private: isPrivate,
+                      auto_init: autoInit,
+                    };
+                    const result = org
+                      ? await octokit.repos.createInOrg({ ...params, org })
+                      : await octokit.repos.createForAuthenticatedUser(params);
+                    return result.data;
+                  } catch (error: any) {
+                    return {
+                      error: error.message,
+                      status: error.status,
+                      details: error.response?.data,
+                    };
+                  }
+                },
+              }),
+            },
+          });
+
+          if (text.trim()) {
+            yield agentOutput({
+              agentId: context.agentId,
+              content: text,
+              threadId,
+            });
+          }
+
+          for (const step of steps) {
+            for (const toolResult of step.toolResults) {
+              if (toolResult.toolName === 'list_repos') {
+                const repos = toolResult.output as any[];
+                yield uiWidget({
+                  agentId: context.agentId,
+                  threadId,
+                  widget: {
+                    kind: 'list',
+                    title: 'GitHub Repositories',
+                    items: (repos || []).map((r: any) => ({
+                      id: String(r.id),
+                      label: r.full_name,
+                      description: r.description || (r.private ? 'Private' : 'Public'),
+                      status: 'done',
+                    })),
+                  },
+                });
+              }
+            }
+          }
+        } catch (error: any) {
+          yield agentOutput({
+            agentId: context.agentId,
+            content: `I encountered an error: ${error.message}`,
+            threadId,
+          });
+        }
+      });
+
+      builder.on('client:ui:widget:response', async function* (event) {
+        if (event.data?.widgetId !== 'github-config-form') return;
+
+        const { openaiApiKey } = event.data.values || {};
+        if (openaiApiKey) {
+          await context.storage.createVariable({
+            key: 'OPENAI_API_KEY',
+            value: openaiApiKey as string,
+            secret: true,
+          });
+
+          yield agentOutput({
+            agentId: context.agentId,
+            content: "OpenAI API key saved! I'm now ready to help you with GitHub.",
+            threadId: event.meta?.threadId,
+          });
+        }
+      });
+
+      // Handle tool calls
+      builder.on('action:list_repos', async function* (event: ToolActionEvent) {
+        const { githubToken } = await getCredentials();
+        const octokit = getOctokit(githubToken);
+        const { limit, visibility, sort } = (event.data || {}) as {
+          limit?: number;
+          visibility?: 'all' | 'public' | 'private';
+          sort?: 'created' | 'updated' | 'pushed' | 'full_name';
+        };
+
+        try {
+          const result = await octokit.repos.listForAuthenticatedUser({
+            per_page: limit || 20,
+            visibility: visibility || 'all',
+            sort: sort || 'updated',
+          });
+
+          yield uiWidget({
+            agentId: context.agentId,
+            threadId: event.meta?.threadId,
+            widget: {
+              kind: 'list',
+              title: 'GitHub Repositories',
+              items: result.data.map((r: any) => ({
+                id: String(r.id),
+                label: r.full_name,
+                description: r.description || (r.private ? 'Private' : 'Public'),
+                status: 'done',
+              })),
+            },
+          });
+
+          yield {
+            type: 'action:list_repos:result',
+            data: {
+              ...result.data,
+              output: `Successfully listed ${result.data.length} repositories.`,
+            },
+            meta: event.meta,
+          };
+        } catch (error: any) {
+          yield {
+            type: 'action:list_repos:result',
+            data: {
+              error: error.message,
+              status: error.status,
+              details: error.response?.data,
+              output: `Failed to list repositories: ${error.message}`,
+            },
+            meta: event.meta,
+          };
+        }
+      });
+
+      builder.on('action:get_repo', async function* (event: ToolActionEvent) {
+        const { githubToken } = await getCredentials();
+        const octokit = getOctokit(githubToken);
+        const { owner, repo } = (event.data || {}) as { owner: string; repo: string };
+
+        try {
+          const result = await octokit.repos.get({ owner, repo });
+          yield {
+            type: 'action:get_repo:result',
+            data: {
+              ...result.data,
+              output: `Successfully retrieved details for ${owner}/${repo}.`,
+            },
+            meta: event.meta,
+          };
+        } catch (error: any) {
+          yield {
+            type: 'action:get_repo:result',
+            data: {
+              error: error.message,
+              status: error.status,
+              details: error.response?.data,
+              output: `Failed to get repository ${owner}/${repo}: ${error.message}`,
+            },
+            meta: event.meta,
+          };
+        }
+      });
+
+      builder.on('action:create_repo', async function* (event: ToolActionEvent) {
+        console.log('action:create_repo', event);
+
+        const { githubToken } = await getCredentials();
+        const octokit = getOctokit(githubToken);
+        const { name, org, description, private: isPrivate, autoInit } = (event.data || {}) as {
+          name: string;
+          org?: string;
+          description?: string;
+          private?: boolean;
+          autoInit?: boolean;
+        };
+
+        try {
+          const params = {
+            name,
+            description,
+            private: isPrivate,
+            auto_init: autoInit,
+          };
+          const result = org
+            ? await octokit.repos.createInOrg({ ...params, org })
+            : await octokit.repos.createForAuthenticatedUser(params);
+
+          yield {
+            type: 'action:create_repo:result',
+            data: {
+              ...result.data,
+              output: `Successfully created repository ${result.data.full_name}.`,
+            },
+            meta: event.meta,
+          };
+        } catch (error: any) {
+          yield {
+            type: 'action:create_repo:result',
+            data: {
+              error: error.message,
+              status: error.status,
+              details: error.response?.data,
+              output: `Failed to create repository ${name}: ${error.message}`,
+            },
+            meta: event.meta,
+          };
+        }
+      });
+    };
+  },
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}