@weavetab/plugin-github 1.0.0 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 fy2ne
+Copyright (c) 2026 fy2ne <hello@fy2ne.me>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,24 +1,20 @@
 # `@weavetab/plugin-github`
 
-> Official [Weavetab](https://weavetab.dev) plugin that gives the agent first-class GitHub
-> access — analyze repositories, read raw source, search and inspect issues, and examine pull
-> requests — **without burning browser turns**.
+> Official [Weavetab](https://weavetab.dev) plugin that gives the agent first-class, modular GitHub
+> access — analyze repositories, read raw source, search issues, examine pull requests, fetch raw diffs,
+> and inspect active tabs directly — **without burning browser turns or API quota**.
 
 [![Trust: Official](https://img.shields.io/badge/trust-official-1e3a8a.svg?style=flat-square)](https://weavetab.dev)
-[![Engine: Weavetab ^2.5.1](https://img.shields.io/badge/engine-weavetab_%5E2.5.1-black.svg?style=flat-square)](https://weavetab.dev)
+[![Engine: Weavetab ^2.5.2](https://img.shields.io/badge/engine-weavetab_%5E2.5.2-black.svg?style=flat-square)](https://weavetab.dev)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](LICENSE)
 
 ---
 
 ## Why
 
-GitHub support ships as an official plugin rather than a built-in tool: the core server stays lean
-at **41 built-in tools**, and GitHub is delivered as the **independently versioned**
-`@weavetab/plugin-github` package that can be installed, updated and removed like any other plugin.
-It registers a single `github` tool (actions: `analyze`, `read`, `issues`, `pr`).
+GitHub capabilities ship as an official modular plugin rather than polluting the core server. The tools are cleanly separated into dedicated, descriptive MCP tools prefixed with `github_`.
 
-All GitHub data is fetched directly over HTTP (`api.github.com` / `raw.githubusercontent.com`),
-so the active browser tab is **never navigated or mutated** and no browser turns are consumed.
+In addition to standard GitHub REST capabilities, the plugin includes **quota-free tools** (`github_read` direct branch reads, `github_diff`, `github_active_tab`) that operate completely outside GitHub's unauthenticated 60 requests/hour REST API rate limit and support private repositories currently active in the user's browser.
 
 ## Install
 
@@ -31,50 +27,80 @@ weavetab plugin add @weavetab/plugin-github
 Because the package name starts with `@weavetab/plugin-`, it is automatically treated as
 **Official** — fully trusted, no verification prompt.
 
-Restart the Weavetab MCP server to activate the tool.
+Restart the Weavetab MCP server to activate the tools.
+
+## The Tools
+
+### 1. `github_analyze`
+High-level repository reconnaissance: metadata, default branch, recursive file tree, and README preview. Results are cached in isolated storage (configurable TTL).
+- **Parameters**: `repo` *(optional, falls back to active tab URL)*.
+
+### 2. `github_read` *(Zero REST API Quota)*
+Fetch raw file contents from `raw.githubusercontent.com`.
+- **Parameters**:
+  - `paths` *(required)*: Array of file paths relative to repo root.
+  - `repo` *(optional)*: Target repository slug or URL.
+  - `branch` *(optional)*: Explicit branch/tag. Avoids API discovery calls.
+  - `line_range` *(optional)*: `[start, end]` 1-indexed lines.
+
+### 3. `github_issues`
+Search, list, or inspect issues and timeline comments.
+- **Parameters**:
+  - `repo` *(optional)*: Target repository slug or URL.
+  - `number` *(optional)*: Specific issue number for full details & comments.
+  - `search` *(optional)*: Search query string.
+  - `labels` *(optional)*: Filter by labels.
+  - `state` *(optional)*: `open` · `closed` · `all`.
+  - `limit` *(optional)*: Max issues to return (default `5`).
+
+### 4. `github_pull_request`
+Examine pull request details, changed files, diff stats, and comments, or list recent pull requests.
+- **Parameters**:
+  - `repo` *(optional)*: Target repository slug or URL.
+  - `number` *(optional)*: PR number for full details & changed files list.
+  - `state` *(optional)*: `open` · `closed` · `all`.
+  - `limit` *(optional)*: Max PRs when listing (default `10`).
+
+### 5. `github_diff` *(Zero API Quota)*
+Fetch raw git diffs or patches directly from `github.com` without consuming REST API rate limits.
+- **Parameters**:
+  - `repo` *(optional)*: Target repository slug or URL.
+  - `pull_number` *(optional)*: Pull request number to fetch diff or patch for.
+  - `commit_sha` *(optional)*: Commit SHA to fetch diff or patch for.
+  - `base` + `head` *(optional)*: Compare range.
+  - `format` *(optional)*: `diff` (unified diff) or `patch` (git patch format). Default `diff`.
+
+### 6. `github_active_tab` *(Zero API Quota & Private Repo Support)*
+Inspect the active browser tab on `github.com` via local CDP evaluation. Extracts repository overview, open PR/issue discussion, or file content directly from the browser DOM with ZERO network or API calls.
+- **Parameters**:
+  - `scope` *(optional)*: `auto` · `summary` · `files` · `comments` · `raw`.
 
-## The `github` tool
-
-A single, well-organized action-dispatch tool.
+---
 
-| Parameter | Applies to | Description |
-|---|---|---|
-| `action` *(required)* | all | `analyze` · `read` · `issues` · `pr` |
-| `repo` | all | `owner/repo` or a full `github.com` URL. Omit to use the active tab's repo. |
-| `paths` | `read` | File paths relative to the repo root. |
-| `line_range` | `read` | Optional `[start, end]`, 1-indexed. |
-| `number` | `issues`, `pr` | Issue / PR number for full detail + comments. |
-| `search` | `issues` | Free-text query (GitHub Search API, scoped to the repo). |
-| `labels` | `issues` | Restrict to issues carrying these labels. |
-| `state` | `issues` | `open` · `closed` · `all` |
-| `limit` | `issues` | Max issues returned (default `5`). |
-
-### Actions
-
-- **`analyze`** — repository metadata, recursive default-branch file tree, and a README snippet.
-  Results are cached in the plugin's isolated storage (TTL configurable).
-- **`read`** — raw contents of the requested `paths`, with optional line ranges and automatic
-  truncation for large files.
-- **`issues`** — inspect one issue with its comments (`number`), or list / search issues.
-- **`pr`** — inspect one pull request with changed files, diff stats and comments (`number`),
-  or list recent pull requests.
-
-### Examples
+## Examples
 
 ```jsonc
-// Analyze a repo
-{ "action": "analyze", "repo": "weavetab/mcp" }
+// Analyze repository structure
+github_analyze({ "repo": "weavetab/mcp" })
 
-// Read two files, lines 1-40 of the first
-{ "action": "read", "repo": "weavetab/mcp", "paths": ["src/index.ts", "README.md"], "line_range": [1, 40] }
+// Read file directly without consuming API rate limit
+github_read({ "repo": "weavetab/mcp", "paths": ["src/index.ts"], "line_range": [1, 50] })
 
 // Search issues by label
-{ "action": "issues", "repo": "weavetab/mcp", "search": "rate limit", "labels": ["bug"], "state": "open" }
+github_issues({ "repo": "weavetab/mcp", "labels": ["bug"], "state": "open" })
 
-// Inspect PR #42
-{ "action": "pr", "repo": "weavetab/mcp", "number": 42 }
+// Inspect Pull Request #42
+github_pull_request({ "repo": "weavetab/mcp", "number": 42 })
+
+// Fetch raw pull request diff (0 API quota used)
+github_diff({ "repo": "weavetab/mcp", "pull_number": 42, "format": "diff" })
+
+// Extract active GitHub tab data from browser DOM
+github_active_tab({ "scope": "auto" })
 ```
 
+---
+
 ## Configuration
 
 Written to `~/.weavetab/plugins/@weavetab_plugin-github/config.json` on first load:
@@ -83,55 +109,25 @@ Written to `~/.weavetab/plugins/@weavetab_plugin-github/config.json` on first lo
 {
   "cacheTtlMs": 1800000,
   "maxReadLines": 200,
-  "defaultIssueLimit": 5
+  "defaultIssueLimit": 5,
+  "token": ""
 }
 ```
 
 | Key | Default | Meaning |
 |---|---|---|
 | `cacheTtlMs` | `1800000` (30 min) | How long an `analyze` result stays cached. |
-| `maxReadLines` | `200` | Files longer than this are truncated when no `line_range` is given. |
-| `defaultIssueLimit` | `5` | Default `limit` for the `issues` action. |
+| `maxReadLines` | `200` | Max lines returned before truncation. |
+| `defaultIssueLimit` | `5` | Default issue count limit. |
+| `token` | `""` | Optional GitHub Personal Access Token (`GITHUB_TOKEN`), bumps rate limit from 60 to 5,000 req/hr. |
+
+---
 
 ## Permissions
 
 | Permission | Why |
 |---|---|
 | `config.read` / `config.write` | Read and persist isolated plugin settings. |
-| `cdp.evaluate` | Read the active tab URL **only**, to infer the target repo when `repo` is omitted. |
-| `network: api.github.com`, `raw.githubusercontent.com`, `github.com` | Fetch public repo data over HTTP. |
-| `tools.add` | Register the single `github` tool. |
-
-No filesystem access beyond the plugin's own sandbox, no HUD/overlay injection, no tab mutation.
-
-## Development
-
-```bash
-npm install
-npm run build      # tsc -> dist/
-npm test           # node:test manifest + schema + handler smoke tests
-npm run dev        # tsc --watch
-```
-
-### Project layout
-
-```text
-plugin-github/
-├── src/index.ts       # definePlugin + registerTool("github")
-├── src/github.ts      # action dispatcher
-├── src/{analyze,read,issues,pr}.ts
-├── src/{repoContext,cache,rateLimiter,types}.ts
-├── weavetab.json      # manifest (permissions + tool schema)
-├── test/              # node:test smoke tests
-└── dist/              # compiled output (generated)
-```
-
-> **Local development note.** Inside the Weavetab monorepo this package pins
-> `"@weavetab/sdk": "file:../../sdk"` so it builds against the in-repo SDK. In the standalone
-> published repository, pin the released SDK instead: `"@weavetab/sdk": "^2.5.1"`.
-
----
-
-## License
-
-MIT © [Weavetab](https://github.com/Weavetab) & [fy2ne](https://github.com/fy2ne)
+| `cdp.evaluate` | Reads URL and DOM on github.com without navigating or mutating. |
+| `network.domains` | `api.github.com`, `raw.githubusercontent.com`, `github.com`. |
+| `tools.add` | Registers the 6 `github_*` MCP tools. |

package/dist/activeTab.d.ts

@@ -0,0 +1,9 @@
+import type { GithubActiveTabArgs, GithubError, GithubRunContext } from "./types.js";
+/**
+ * `github_active_tab` — extract structured information from the active browser
+ * tab when open on github.com.
+ *
+ * Runs entirely via local CDP evaluation with ZERO API calls. Works on both public
+ * and private repositories that the user is authenticated to view in their browser.
+ */
+export declare function githubActiveTab(ctx: GithubRunContext, args?: GithubActiveTabArgs): Promise<any | GithubError>;

package/dist/activeTab.js

@@ -0,0 +1,126 @@
+/**
+ * `github_active_tab` — extract structured information from the active browser
+ * tab when open on github.com.
+ *
+ * Runs entirely via local CDP evaluation with ZERO API calls. Works on both public
+ * and private repositories that the user is authenticated to view in their browser.
+ */
+export async function githubActiveTab(ctx, args = {}) {
+    const session = ctx.session;
+    if (!session) {
+        return {
+            error: "NO_ACTIVE_SESSION",
+            message: "No active browser session connected. Open a github.com page in Weavetab.",
+        };
+    }
+    const requestedScope = args.scope || "auto";
+    const evalExpression = `(() => {
+    try {
+      const url = new URL(window.location.href);
+      if (!url.hostname.includes("github.com")) {
+        return { error: "NOT_ON_GITHUB", message: "Active tab is not on github.com (" + url.hostname + ")" };
+      }
+
+      const parts = url.pathname.split("/").filter(Boolean);
+      if (parts.length < 2) {
+        return {
+          url: url.href,
+          page_type: "github_home_or_profile",
+          title: document.title,
+        };
+      }
+
+      const owner = parts[0];
+      const repo = parts[1];
+      const section = parts[2] || "root";
+      const idOrBranch = parts[3] || "";
+      const scope = ${JSON.stringify(requestedScope)};
+
+      const res = {
+        url: url.href,
+        owner,
+        repo,
+        page_type: section === "root" ? "repo_overview" : section,
+        title: document.title,
+      };
+
+      // Pull Request or Issue views
+      if (section === "pull" || section === "issues") {
+        const titleEl = document.querySelector("bdi.markdown-title, .gh-header-title, [data-testid='issue-title'], h1");
+        const stateBadge = document.querySelector("[data-testid='state-label'], [data-testid='issue-state-badge'], .State, [data-state]");
+        const bodyEl = document.querySelector("[data-testid='comment-body'], .comment-body");
+
+        // Files scope on PR
+        if (scope === "files") {
+          const fileEls = Array.from(document.querySelectorAll("[data-tagsearch-path], [data-path], .file-header [data-path], .file-info a"));
+          const changedFiles = Array.from(new Set(fileEls.map((el) => el.getAttribute("data-tagsearch-path") || el.getAttribute("data-path") || el.textContent?.trim()).filter(Boolean)));
+          return {
+            ...res,
+            number: parseInt(idOrBranch, 10) || null,
+            item_title: titleEl?.textContent?.replace(/\\s+/g, " ")?.trim(),
+            files_count: changedFiles.length,
+            files: changedFiles,
+          };
+        }
+
+        const maxComments = scope === "comments" ? 50 : 5;
+        const commentEls = Array.from(document.querySelectorAll("[data-testid='issue-comment-item'], .timeline-comment, .timeline-comment-group")).slice(0, maxComments);
+        const comments = commentEls.map((el) => {
+          const authorEl = el.querySelector("[data-testid='author-avatar-link'], a.author, .author");
+          const body = el.querySelector("[data-testid='comment-body'], .comment-body");
+          return {
+            author: authorEl?.textContent?.trim() || "unknown",
+            preview: (body?.textContent?.trim() || "").slice(0, 400),
+          };
+        });
+
+        return {
+          ...res,
+          number: parseInt(idOrBranch, 10) || null,
+          item_title: titleEl?.textContent?.replace(/\\s+/g, " ")?.trim(),
+          state: stateBadge?.textContent?.trim(),
+          body_preview: bodyEl?.textContent?.trim().slice(0, 1000),
+          comments_count: comments.length,
+          recent_comments: comments,
+        };
+      }
+
+      // Blob code viewer
+      if (section === "blob") {
+        const path = parts.slice(4).join("/");
+        const codeContainer = document.querySelector("#read-only-cursor-text-area, [data-target='react-app.embeddedData'], .blob-wrapper table, textarea[aria-label='file content']");
+        const rawText = codeContainer ? codeContainer.textContent : document.querySelector("article, main")?.textContent;
+        return {
+          ...res,
+          file_path: path,
+          branch: idOrBranch,
+          content_preview: (rawText || "").slice(0, 2000),
+        };
+      }
+
+      // Default repo root overview
+      const descEl = document.querySelector("p.f4, .BorderGrid-cell p, [data-testid='repo-description']");
+      const readmeEl = document.querySelector("#readme article, [data-testid='readme'] article");
+      return {
+        ...res,
+        description: descEl?.textContent?.trim() || null,
+        readme_preview: readmeEl?.textContent?.trim().slice(0, 800) || null,
+      };
+    } catch (e) {
+      return { error: "EVAL_ERROR", message: String(e) };
+    }
+  })()`;
+    try {
+        const { result } = await session.Runtime.evaluate({
+            expression: evalExpression,
+            returnByValue: true,
+        });
+        return result.value;
+    }
+    catch (err) {
+        return {
+            error: "CDP_EVALUATION_FAILED",
+            message: err?.message || "Failed to inspect active tab DOM",
+        };
+    }
+}

package/dist/analyze.js

@@ -1,11 +1,7 @@
 import { getRepoContext, isGithubError } from "./repoContext.js";
 import { loadRepoCache, saveRepoCache } from "./cache.js";
-import { canMakeApiCall, handleApiResponse } from "./rateLimiter.js";
+import { canMakeApiCall, handleApiResponse, getApiHeaders } from "./rateLimiter.js";
 const README_CANDIDATES = ["README.md", "README", "readme.md", "Readme.md", "README.txt"];
-const API_HEADERS = {
-    Accept: "application/vnd.github.v3+json",
-    "User-Agent": "Weavetab-GitHub-Plugin",
-};
 /**
  * `analyze` action — repository metadata, recursive default-branch file tree and
  * a README snippet. Results are cached in the plugin's isolated storage.
@@ -21,9 +17,10 @@ export async function githubAnalyze(ctx, repoSlug) {
     const rateLimitCheck = canMakeApiCall();
     if (isGithubError(rateLimitCheck))
         return rateLimitCheck;
+    const apiHeaders = getApiHeaders(ctx.token);
     // 1. Repo metadata
     const repoRes = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
-        headers: API_HEADERS,
+        headers: apiHeaders,
     });
     const handledRepoRes = handleApiResponse(repoRes);
     if (isGithubError(handledRepoRes))
@@ -46,7 +43,7 @@ export async function githubAnalyze(ctx, repoSlug) {
     if (isGithubError(rateLimitCheck2))
         return rateLimitCheck2;
     let file_tree = [];
-    const treeRes = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/trees/${default_branch}?recursive=1`, { headers: API_HEADERS });
+    const treeRes = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/trees/${default_branch}?recursive=1`, { headers: apiHeaders });
     const handledTreeRes = handleApiResponse(treeRes);
     if (isGithubError(handledTreeRes))
         return handledTreeRes;

package/dist/cache.d.ts

@@ -4,6 +4,6 @@ import type { GithubRepoCache } from "./types.js";
  * Load a previously analyzed repository from the plugin's isolated storage.
  * Returns null when absent, malformed, or older than `ttlMs`.
  */
-export declare function loadRepoCache(owner: string, repo: string, store: PluginStorage, ttlMs: number): Promise<GithubRepoCache | null>;
+export declare function loadRepoCache(owner: string, repo: string, store: PluginStorage | undefined | null, ttlMs: number): Promise<GithubRepoCache | null>;
 /** Persist an analysis result into the plugin's isolated storage. */
-export declare function saveRepoCache(data: GithubRepoCache, store: PluginStorage): Promise<void>;
+export declare function saveRepoCache(data: GithubRepoCache, store: PluginStorage | undefined | null): Promise<void>;

package/dist/cache.js

@@ -10,6 +10,8 @@ function cacheFile(owner, repo) {
  * Returns null when absent, malformed, or older than `ttlMs`.
  */
 export async function loadRepoCache(owner, repo, store, ttlMs) {
+    if (!store || typeof store.getJSON !== "function")
+        return null;
     const data = await store.getJSON(cacheFile(owner, repo));
     if (!data || typeof data.analyzed_at !== "number")
         return null;
@@ -19,5 +21,7 @@ export async function loadRepoCache(owner, repo, store, ttlMs) {
 }
 /** Persist an analysis result into the plugin's isolated storage. */
 export async function saveRepoCache(data, store) {
+    if (!store || typeof store.setJSON !== "function")
+        return;
     await store.setJSON(cacheFile(data.owner, data.repo), data);
 }

package/dist/diff.d.ts

@@ -0,0 +1,10 @@
+import type { DiffStats, GithubDiffArgs, GithubError, GithubRunContext } from "./types.js";
+/**
+ * Extracts structured diff statistics from unified diff output.
+ */
+export declare function parseDiffStats(diffText: string): DiffStats;
+/**
+ * `github_diff` — fetch raw git diffs or patches directly from github.com without
+ * consuming any GitHub REST API rate-limited quota.
+ */
+export declare function githubDiff(ctx: GithubRunContext, args?: GithubDiffArgs): Promise<any | GithubError>;

package/dist/diff.js

@@ -0,0 +1,117 @@
+import { getDetailedRepoContext, isGithubError } from "./repoContext.js";
+/**
+ * Extracts structured diff statistics from unified diff output.
+ */
+export function parseDiffStats(diffText) {
+    const files = [];
+    let additions = 0;
+    let deletions = 0;
+    const lines = diffText.split("\n");
+    for (const line of lines) {
+        if (line.startsWith("diff --git")) {
+            const match = line.match(/diff --git a\/(.+?)\s+b\/(.+)/);
+            if (match && match[2]) {
+                files.push(match[2]);
+            }
+        }
+        else if (line.startsWith("+") && !line.startsWith("+++")) {
+            additions++;
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions++;
+        }
+    }
+    return {
+        files_changed: Array.from(new Set(files)),
+        additions,
+        deletions,
+    };
+}
+/**
+ * `github_diff` — fetch raw git diffs or patches directly from github.com without
+ * consuming any GitHub REST API rate-limited quota.
+ */
+export async function githubDiff(ctx, args = {}) {
+    const context = await getDetailedRepoContext(ctx.session, args.repo);
+    if (isGithubError(context))
+        return context;
+    const { owner, repo } = context;
+    const ext = args.format === "patch" ? "patch" : "diff";
+    // Target resolution with tab auto-inference fallback
+    const pullNumber = typeof args.pull_number === "number" ? args.pull_number : context.pullNumber;
+    const commitSha = typeof args.commit_sha === "string" && args.commit_sha.trim()
+        ? args.commit_sha.trim()
+        : typeof pullNumber !== "number"
+            ? context.commitSha
+            : undefined;
+    let targetUrl;
+    if (typeof pullNumber === "number") {
+        targetUrl = `https://github.com/${owner}/${repo}/pull/${pullNumber}.${ext}`;
+    }
+    else if (commitSha) {
+        targetUrl = `https://github.com/${owner}/${repo}/commit/${commitSha}.${ext}`;
+    }
+    else if (args.base && args.head) {
+        const base = args.base.trim();
+        const head = args.head.trim();
+        targetUrl = `https://github.com/${owner}/${repo}/compare/${base}...${head}.${ext}`;
+    }
+    else {
+        return {
+            error: "MISSING_TARGET",
+            message: "github_diff requires 'pull_number', 'commit_sha', or 'base'+'head' (or navigate to a PR or commit in the active browser tab).",
+        };
+    }
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15_000);
+        const res = await fetch(targetUrl, {
+            signal: controller.signal,
+            headers: {
+                "User-Agent": "Weavetab-GitHub-Plugin",
+            },
+        });
+        clearTimeout(timeout);
+        if (res.status === 404) {
+            return {
+                error: "NOT_FOUND",
+                message: `Resource not found at ${targetUrl}. Ensure the PR, commit, or compare range exists in ${owner}/${repo}.`,
+            };
+        }
+        if (!res.ok) {
+            return {
+                error: "FETCH_FAILED",
+                status: res.status,
+                message: `HTTP ${res.status} while fetching diff from ${targetUrl}`,
+            };
+        }
+        const text = await res.text();
+        const lines = text.split("\n");
+        const total_lines = lines.length;
+        let content = text;
+        let truncated = false;
+        // Safeguard for very large diffs
+        const maxLines = ctx.maxReadLines * 4;
+        if (total_lines > maxLines) {
+            content = lines.slice(0, maxLines).join("\n");
+            truncated = true;
+        }
+        const stats = parseDiffStats(text);
+        return {
+            owner,
+            repo,
+            target_url: targetUrl,
+            format: ext,
+            total_lines,
+            truncated,
+            stats,
+            diff: content,
+        };
+    }
+    catch (err) {
+        return {
+            error: "FETCH_ERROR",
+            message: err?.message || "Failed to fetch raw diff",
+        };
+    }
+}

package/dist/github.d.ts

@@ -2,10 +2,11 @@ import type { GithubError, GithubRunContext, GithubToolArgs } from "./types.js";
 import { githubAnalyze } from "./analyze.js";
 import { githubRead } from "./read.js";
 import { githubIssues } from "./issues.js";
-import { githubGetPr } from "./pr.js";
+import { githubPullRequest, githubGetPr } from "./pr.js";
+import { githubDiff } from "./diff.js";
+import { githubActiveTab } from "./activeTab.js";
 /**
- * Single entry point for the `github` MCP tool. Dispatches to the matching
- * action handler and funnels every result through a plain serializable value.
+ * Backwards-compatible legacy entry point for single-tool callers.
  */
 export declare function runGithub(ctx: GithubRunContext, args: GithubToolArgs): Promise<any | GithubError>;
-export { githubAnalyze, githubRead, githubIssues, githubGetPr };
+export { githubAnalyze, githubRead, githubIssues, githubPullRequest, githubGetPr, githubDiff, githubActiveTab, };

package/dist/github.js

@@ -1,10 +1,11 @@
 import { githubAnalyze } from "./analyze.js";
 import { githubRead } from "./read.js";
 import { githubIssues } from "./issues.js";
-import { githubGetPr } from "./pr.js";
+import { githubPullRequest, githubGetPr } from "./pr.js";
+import { githubDiff } from "./diff.js";
+import { githubActiveTab } from "./activeTab.js";
 /**
- * Single entry point for the `github` MCP tool. Dispatches to the matching
- * action handler and funnels every result through a plain serializable value.
+ * Backwards-compatible legacy entry point for single-tool callers.
  */
 export async function runGithub(ctx, args) {
     switch (args.action) {
@@ -18,7 +19,7 @@ export async function runGithub(ctx, args) {
                     message: "action 'read' requires a 'paths' array with at least one file path.",
                 };
             }
-            return githubRead(ctx, { repo: args.repo, paths, line_range: args.line_range });
+            return githubRead(ctx, { repo: args.repo, paths, branch: args.branch, line_range: args.line_range });
         }
         case "issues":
             return githubIssues(ctx, {
@@ -30,7 +31,7 @@ export async function runGithub(ctx, args) {
                 limit: args.limit,
             });
         case "pr":
-            return githubGetPr(ctx, { repo: args.repo, number: args.number, state: args.state, limit: args.limit });
+            return githubPullRequest(ctx, { repo: args.repo, number: args.number, state: args.state, limit: args.limit });
         default:
             return {
                 error: "INVALID_ACTION",
@@ -38,4 +39,4 @@ export async function runGithub(ctx, args) {
             };
     }
 }
-export { githubAnalyze, githubRead, githubIssues, githubGetPr };
+export { githubAnalyze, githubRead, githubIssues, githubPullRequest, githubGetPr, githubDiff, githubActiveTab, };

package/dist/index.d.ts

@@ -1,16 +1,15 @@
 /**
  * @weavetab/plugin-github
- * Official Weavetab GitHub plugin — repository analysis, raw file reads, issue
- * search/inspection and pull request inspection over the GitHub REST API.
+ * Official Weavetab GitHub plugin — modular GitHub tools with zero-API options.
  *
- * All GitHub data is fetched over HTTP, so no browser turns are consumed and the
- * active tab is never navigated or mutated.
+ * All GitHub data is fetched over HTTP or directly via active tab DOM evaluation,
+ * so browser turns and rate-limited API quotas are minimized.
  *
  * Author: fy2ne
  * License: MIT
  */
 export * from "./types.js";
-export { runGithub } from "./github.js";
+export * from "./github.js";
 export declare const githubPlugin: import("@weavetab/sdk").WeavetabPluginDefinition;
 export default githubPlugin;
 export declare const plugin: import("@weavetab/sdk").WeavetabPluginDefinition;