@meetopenbot/github 0.0.1 → 0.1.0

package/README.md

@@ -1,53 +1,31 @@
-# GitHub OpenBot Plugin
+# @meetopenbot/github
 
-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.
+GitHub specialist agent for OpenBot, backed by GitHub's official remote MCP.
 
-## Features
+## Setup
 
-- **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.
+The agent expects `OPENAI_API_KEY` in the environment.
 
-## Configuration
+If no GitHub token is already available (plugin config, `GITHUB_TOKEN` env, or a workspace variable), the agent shows a form. Submitting it stores the token as a secret `GITHUB_TOKEN` workspace variable.
 
-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.
+You can also set the token in `AGENT.md`:
 
-### Config Schema
+```yaml
+plugins:
+  - id: "@meetopenbot/github"
+    config:
+      githubToken: ghp_your_token_here
+```
 
-- `githubToken` (Required): Your GitHub Personal Access Token.
-- `openaiApiKey` (Optional): OpenAI API key for natural language support (can also be set via environment).
+Create a Personal Access Token at [GitHub Developer Settings](https://github.com/settings/tokens) with `repo` scope.
 
 ## Usage
 
-### Natural Language
-
-You can ask things like:
+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
+- "Create an issue in owner/repo titled Fix login bug"
+- "Show the diff for PR 42 in owner/repo"
 
-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.
+Pull request and commit file changes render as a **Diff** widget in the chat timeline.

package/dist/agent.js

@@ -0,0 +1,188 @@
+import { createMCPClient } from '@ai-sdk/mcp';
+import { createOpenAI } from '@ai-sdk/openai';
+import { toolTraceWidget } from '@meetopenbot/plugin-sdk';
+import { generateText, stepCountIs } from 'ai';
+import { diffWidgetFromTool, prIdentityFromInput, shouldFollowUpPrFiles, toolInputFrom, unwrapToolOutput, } from './diff.js';
+export const GITHUB_MCP_URL = 'https://api.githubcopilot.com/mcp/';
+const TOOL_OUTPUT_MAX_LENGTH = 2_000;
+function formatToolOutput(output) {
+    if (output === undefined || output === null)
+        return 'Done.';
+    if (typeof output === 'string')
+        return truncate(output);
+    try {
+        return truncate(JSON.stringify(output, null, 2));
+    }
+    catch {
+        return truncate(String(output));
+    }
+}
+function truncate(text) {
+    if (text.length <= TOOL_OUTPUT_MAX_LENGTH)
+        return text;
+    return `${text.slice(0, TOOL_OUTPUT_MAX_LENGTH)}…`;
+}
+function toolCallWidget(args) {
+    return toolTraceWidget({
+        widgetId: args.widgetId,
+        groupId: 'github:tools',
+        title: args.title,
+        body: args.body,
+    });
+}
+function findMcpTool(tools, name) {
+    const direct = tools[name];
+    if (direct)
+        return direct;
+    const needle = name.toLowerCase();
+    for (const [key, tool] of Object.entries(tools)) {
+        if (key.toLowerCase() === needle || key.toLowerCase().includes(needle)) {
+            return tool;
+        }
+    }
+    return undefined;
+}
+async function fetchPrFilesDiffWidget(args) {
+    const identity = prIdentityFromInput(args.input);
+    if (!identity)
+        return null;
+    const tool = findMcpTool(args.tools, 'pull_request_read');
+    if (!tool?.execute)
+        return null;
+    try {
+        const output = await tool.execute({
+            method: 'get_files',
+            owner: identity.owner,
+            repo: identity.repo,
+            pullNumber: identity.pullNumber,
+            perPage: 100,
+        }, { toolCallId: args.widgetId, messages: [] });
+        return diffWidgetFromTool({
+            widgetId: args.widgetId,
+            toolName: args.toolName,
+            input: {
+                ...(typeof args.input === 'object' && args.input ? args.input : {}),
+                method: 'get_files',
+                ...identity,
+            },
+            output,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+const SYSTEM_PROMPT = `You are a GitHub assistant. Use the GitHub MCP tools to help with repositories, issues, and pull requests.
+Parse owner/repo from "owner/repo" when the user provides that format.
+Be concise and helpful.
+
+When the user asks to inspect, review, or see a pull request, commit, or code change:
+- Call pull_request_read with method get for title/author/status if needed.
+- Always also call pull_request_read with method get_files (preferred; includes per-file patches) or get_diff.
+A Diff widget is rendered from that file/diff result — keep your text reply to a short summary, not a pasted patch.`;
+export async function* runGithubAgent(args) {
+    const mcpClient = await createMCPClient({
+        transport: {
+            type: 'http',
+            url: GITHUB_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${args.githubToken}`,
+                'X-MCP-Toolsets': 'repos,issues,pull_requests',
+            },
+        },
+    });
+    const queue = [];
+    let wake;
+    let agentDone = false;
+    let agentError;
+    const enqueue = (event) => {
+        queue.push(event);
+        wake?.();
+        wake = undefined;
+    };
+    const waitForQueue = () => new Promise((resolve) => {
+        wake = resolve;
+    });
+    const agentTask = (async () => {
+        try {
+            const tools = await mcpClient.tools();
+            const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+            const result = await generateText({
+                model: openai('gpt-4o'),
+                stopWhen: stepCountIs(5),
+                system: SYSTEM_PROMPT,
+                prompt: args.prompt,
+                tools,
+                onToolExecutionStart: ({ toolCall }) => {
+                    enqueue({
+                        kind: 'widget',
+                        widget: toolCallWidget({
+                            widgetId: toolCall.toolCallId,
+                            title: toolCall.toolName,
+                        }),
+                    });
+                },
+                onToolExecutionEnd: async ({ toolCall, toolOutput }) => {
+                    const input = toolInputFrom(toolCall, toolOutput);
+                    const payload = unwrapToolOutput(toolOutput);
+                    enqueue({
+                        kind: 'widget',
+                        widget: toolCallWidget({
+                            widgetId: toolCall.toolCallId,
+                            title: toolCall.toolName,
+                            body: formatToolOutput(payload),
+                        }),
+                    });
+                    const widgetId = `github-diff:${toolCall.toolCallId}`;
+                    let widget = diffWidgetFromTool({
+                        widgetId,
+                        toolName: toolCall.toolName,
+                        input,
+                        output: payload,
+                    });
+                    if (!widget &&
+                        shouldFollowUpPrFiles({
+                            toolName: toolCall.toolName,
+                            input,
+                            hasDiffWidget: false,
+                        })) {
+                        widget = await fetchPrFilesDiffWidget({
+                            tools: tools,
+                            widgetId,
+                            toolName: toolCall.toolName,
+                            input,
+                        });
+                    }
+                    if (widget)
+                        enqueue({ kind: 'widget', widget });
+                },
+            });
+            if (result.text.trim()) {
+                enqueue({ kind: 'reply', content: result.text.trim() });
+            }
+        }
+        catch (error) {
+            agentError = error;
+        }
+        finally {
+            agentDone = true;
+            wake?.();
+            wake = undefined;
+        }
+    })();
+    try {
+        while (!agentDone || queue.length > 0) {
+            if (queue.length === 0) {
+                await waitForQueue();
+                continue;
+            }
+            yield queue.shift();
+        }
+        await agentTask;
+        if (agentError)
+            throw agentError;
+    }
+    finally {
+        await mcpClient.close().catch(() => undefined);
+    }
+}

package/dist/diff.js

@@ -0,0 +1,346 @@
+const MAX_FILES = 40;
+const MAX_PATCH_CHARS = 48_000;
+const LANG_BY_EXT = {
+    ts: 'typescript',
+    tsx: 'tsx',
+    js: 'javascript',
+    jsx: 'jsx',
+    mjs: 'javascript',
+    cjs: 'javascript',
+    py: 'python',
+    go: 'go',
+    rs: 'rust',
+    rb: 'ruby',
+    java: 'java',
+    kt: 'kotlin',
+    swift: 'swift',
+    cs: 'csharp',
+    cpp: 'cpp',
+    cc: 'cpp',
+    cxx: 'cpp',
+    c: 'c',
+    h: 'c',
+    hpp: 'cpp',
+    md: 'markdown',
+    json: 'json',
+    css: 'css',
+    scss: 'scss',
+    html: 'html',
+    yml: 'yaml',
+    yaml: 'yaml',
+    toml: 'toml',
+    sh: 'bash',
+    bash: 'bash',
+    zsh: 'bash',
+    sql: 'sql',
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function asNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function languageFromPath(path) {
+    const base = path.split('/').pop() ?? path;
+    const ext = base.includes('.') ? base.slice(base.lastIndexOf('.') + 1).toLowerCase() : '';
+    return LANG_BY_EXT[ext];
+}
+function mapStatus(status, oldPath) {
+    switch (status) {
+        case 'added':
+            return 'added';
+        case 'removed':
+        case 'deleted':
+            return 'deleted';
+        case 'renamed':
+        case 'copied':
+            return 'renamed';
+        default:
+            return oldPath ? 'renamed' : 'modified';
+    }
+}
+function countPatchStats(patch) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of patch.split('\n')) {
+        if (line.startsWith('+') && !line.startsWith('+++'))
+            additions += 1;
+        else if (line.startsWith('-') && !line.startsWith('---'))
+            deletions += 1;
+    }
+    return { additions, deletions };
+}
+function capPatch(patch) {
+    if (!patch)
+        return {};
+    if (patch.length <= MAX_PATCH_CHARS)
+        return { patch };
+    return { patch: patch.slice(0, MAX_PATCH_CHARS), truncated: true };
+}
+export function unwrapToolOutput(output) {
+    if (output == null)
+        return output;
+    if (typeof output === 'string') {
+        const trimmed = output.trim();
+        if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch {
+                return output;
+            }
+        }
+        return output;
+    }
+    if (Array.isArray(output)) {
+        if (output.length > 0 &&
+            output.every((part) => typeof part === 'string' ||
+                (isRecord(part) && (typeof part.text === 'string' || typeof part.value === 'string')))) {
+            const text = output
+                .map((part) => {
+                if (typeof part === 'string')
+                    return part;
+                if (isRecord(part))
+                    return asString(part.text) ?? asString(part.value) ?? '';
+                return '';
+            })
+                .join('\n');
+            return unwrapToolOutput(text);
+        }
+        return output;
+    }
+    if (isRecord(output)) {
+        // AI SDK onToolExecutionEnd passes { type: 'tool-result', output } / { type: 'tool-error', error }.
+        if (output.type === 'tool-result' && 'output' in output) {
+            return unwrapToolOutput(output.output);
+        }
+        if (output.type === 'tool-error' && 'error' in output) {
+            return unwrapToolOutput(output.error);
+        }
+        if (typeof output.text === 'string' && Object.keys(output).length <= 3) {
+            return unwrapToolOutput(output.text);
+        }
+        if (Array.isArray(output.content))
+            return unwrapToolOutput(output.content);
+        if ('value' in output)
+            return unwrapToolOutput(output.value);
+    }
+    return output;
+}
+/** Prefer the AI SDK tool-result input; fall back to the tool call. */
+export function toolInputFrom(toolCall, toolOutput) {
+    if (isRecord(toolOutput) && 'input' in toolOutput)
+        return toolOutput.input;
+    if (isRecord(toolCall) && 'input' in toolCall)
+        return toolCall.input;
+    return undefined;
+}
+export function prIdentityFromInput(input) {
+    if (!isRecord(input))
+        return null;
+    const owner = asString(input.owner);
+    const repo = asString(input.repo);
+    const pullNumber = asNumber(input.pullNumber) ?? asNumber(input.pull_number);
+    if (!owner || !repo || pullNumber == null)
+        return null;
+    return { owner, repo, pullNumber };
+}
+const PR_FILE_FOLLOW_UP_METHODS = new Set(['get', 'get_files', 'get_diff']);
+/** True when pull_request_read didn't yield a Diff widget but we can still fetch files. */
+export function shouldFollowUpPrFiles(args) {
+    if (args.hasDiffWidget)
+        return false;
+    if (!args.toolName.toLowerCase().includes('pull_request_read'))
+        return false;
+    if (!prIdentityFromInput(args.input))
+        return false;
+    const method = isRecord(args.input) ? asString(args.input.method)?.toLowerCase() : undefined;
+    if (!method)
+        return true;
+    return PR_FILE_FOLLOW_UP_METHODS.has(method);
+}
+function toDiffFile(file) {
+    const path = asString(file.filename);
+    if (!path)
+        return null;
+    const oldPath = asString(file.previous_filename);
+    const rawPatch = asString(file.patch);
+    const capped = capPatch(rawPatch);
+    const stats = rawPatch ? countPatchStats(rawPatch) : { additions: 0, deletions: 0 };
+    return {
+        path,
+        ...(oldPath ? { oldPath } : {}),
+        status: mapStatus(asString(file.status), oldPath),
+        ...(languageFromPath(path) ? { language: languageFromPath(path) } : {}),
+        additions: asNumber(file.additions) ?? (stats.additions || undefined),
+        deletions: asNumber(file.deletions) ?? (stats.deletions || undefined),
+        ...capped,
+    };
+}
+export function splitUnifiedDiff(raw) {
+    const text = raw.replace(/\r\n/g, '\n');
+    const starts = [];
+    const header = /^diff --git /gm;
+    let match;
+    while ((match = header.exec(text)))
+        starts.push(match.index);
+    if (starts.length === 0) {
+        if (!text.trim())
+            return [];
+        const stats = countPatchStats(text);
+        const capped = capPatch(text);
+        return [
+            {
+                path: 'diff',
+                status: 'modified',
+                additions: stats.additions || undefined,
+                deletions: stats.deletions || undefined,
+                ...capped,
+            },
+        ];
+    }
+    return starts
+        .map((start, index) => {
+        const chunk = text.slice(start, starts[index + 1]);
+        const names = /^diff --git a\/(.+?) b\/(.+)$/m.exec(chunk);
+        const oldPath = names?.[1] ?? 'unknown';
+        const path = names?.[2] ?? oldPath;
+        let status = 'modified';
+        if (/^new file mode /m.test(chunk) || oldPath === '/dev/null')
+            status = 'added';
+        else if (/^deleted file mode /m.test(chunk) || path === '/dev/null')
+            status = 'deleted';
+        else if (/^rename from /m.test(chunk) || oldPath !== path)
+            status = 'renamed';
+        const stats = countPatchStats(chunk);
+        return {
+            path: path === '/dev/null' ? oldPath : path,
+            ...(status === 'renamed' && oldPath !== path ? { oldPath } : {}),
+            status,
+            ...(languageFromPath(path) ? { language: languageFromPath(path) } : {}),
+            additions: stats.additions || undefined,
+            deletions: stats.deletions || undefined,
+            ...capPatch(chunk),
+        };
+    })
+        .slice(0, MAX_FILES);
+}
+function githubFileFromUnknown(item) {
+    if (!isRecord(item))
+        return null;
+    const filename = asString(item.filename) ?? asString(item.path) ?? asString(item.name);
+    if (!filename)
+        return null;
+    return {
+        filename,
+        previous_filename: asString(item.previous_filename) ??
+            asString(item.previousFilename) ??
+            asString(item.oldPath) ??
+            asString(item.old_path),
+        status: item.status,
+        additions: item.additions,
+        deletions: item.deletions,
+        patch: item.patch,
+    };
+}
+function filesFromUnknown(payload) {
+    if (Array.isArray(payload)) {
+        const files = payload
+            .map(githubFileFromUnknown)
+            .filter((file) => file != null);
+        return files.length > 0 ? files : null;
+    }
+    if (isRecord(payload) && Array.isArray(payload.files)) {
+        return filesFromUnknown(payload.files);
+    }
+    return null;
+}
+function isChangedFilePayload(payload) {
+    const files = filesFromUnknown(payload);
+    if (!files?.length)
+        return false;
+    return files.some((file) => typeof file.patch === 'string' ||
+        typeof file.status === 'string' ||
+        typeof file.additions === 'number' ||
+        typeof file.deletions === 'number');
+}
+function summarize(files) {
+    const additions = files.reduce((sum, file) => sum + (file.additions ?? 0), 0);
+    const deletions = files.reduce((sum, file) => sum + (file.deletions ?? 0), 0);
+    const fileLabel = files.length === 1 ? '1 file' : `${files.length} files`;
+    if (!additions && !deletions)
+        return fileLabel;
+    return `${fileLabel} · +${additions} −${deletions}`;
+}
+function titleFromInput(input) {
+    if (!input)
+        return 'Diff';
+    const owner = asString(input.owner);
+    const repo = asString(input.repo);
+    const pullNumber = asNumber(input.pullNumber) ?? asNumber(input.pull_number);
+    const sha = asString(input.sha);
+    if (owner && repo && pullNumber != null)
+        return `${owner}/${repo}#${pullNumber}`;
+    if (owner && repo && sha)
+        return `${owner}/${repo}@${sha.slice(0, 7)}`;
+    if (owner && repo)
+        return `${owner}/${repo}`;
+    return 'Diff';
+}
+function filesFromPayload(payload) {
+    if (typeof payload === 'string') {
+        const trimmed = payload.trim();
+        if (trimmed.startsWith('diff --git') || trimmed.startsWith('@@')) {
+            return splitUnifiedDiff(payload);
+        }
+        return null;
+    }
+    const githubFiles = filesFromUnknown(payload);
+    if (!githubFiles)
+        return null;
+    const files = githubFiles
+        .map(toDiffFile)
+        .filter((file) => file != null)
+        .slice(0, MAX_FILES);
+    return files.length > 0 ? files : null;
+}
+export function diffWidgetFromTool(args) {
+    const toolName = args.toolName.toLowerCase();
+    const input = isRecord(args.input) ? args.input : undefined;
+    const method = asString(input?.method)?.toLowerCase();
+    const payload = unwrapToolOutput(args.output);
+    const looksLikeDiffTool = (toolName.includes('pull_request_read') &&
+        (method === 'get_files' || method === 'get_diff')) ||
+        toolName.includes('get_commit') ||
+        toolName.includes('get_diff') ||
+        (typeof payload === 'string' && payload.trim().startsWith('diff --git')) ||
+        isChangedFilePayload(payload);
+    if (!looksLikeDiffTool)
+        return null;
+    const files = filesFromPayload(payload);
+    if (!files || files.length === 0)
+        return null;
+    return {
+        kind: 'diff',
+        widgetId: args.widgetId,
+        title: titleFromInput(input),
+        description: summarize(files),
+        files,
+        size: 'full',
+        display: 'expanded',
+        metadata: {
+            toolName: args.toolName,
+            ...(method ? { method } : {}),
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@meetopenbot/plugin-sdk';
+declare const plugin: Plugin;
+export { plugin };
+export default plugin;