@meetopenbot/github 0.0.1 → 0.1.1

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;