@meetopenbot/github 0.0.1 → 0.1.1

package/src/index.ts

@@ -1,418 +0,0 @@
-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

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