@circuitwall/github-langchain 0.1.0

package/dist/index.cjs

@@ -0,0 +1,850 @@
+'use strict';
+
+var tools = require('@langchain/core/tools');
+var zod = require('zod');
+
+// src/index.ts
+function parseJsonSafe(text, fallback) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return fallback;
+  }
+}
+function isLikelyBinary(buf) {
+  const len = Math.min(buf.length, 4096);
+  if (len === 0) return false;
+  let suspicious = 0;
+  for (let i = 0; i < len; i++) {
+    const b = buf[i];
+    if (b === 0) return true;
+    if (b < 9 || b > 13 && b < 32) suspicious++;
+  }
+  return suspicious / len > 0.05;
+}
+var _resolver = resolveGithubAuthFromEnv;
+function setAuthResolver(fn) {
+  _resolver = fn;
+}
+function resolveGithubAuthFromEnv() {
+  const env = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+  if (env && env.trim()) return { token: env.trim() };
+  return {
+    error: "GitHub not configured. Set GITHUB_TOKEN or GH_TOKEN env var, or call setAuthResolver() with your own credential provider."
+  };
+}
+function _resolveGithubAuth() {
+  return resolveAuth();
+}
+function resolveAuth() {
+  return _resolver();
+}
+var API = "https://api.github.com";
+async function ghFetch(auth, path, init) {
+  const url = path.startsWith("http") ? path : `${API}${path}`;
+  const res = await fetch(url, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${auth.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "User-Agent": "circuitwall-github-langchain",
+      ...init?.headers ?? {}
+    }
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    return { error: `GitHub ${res.status}: ${text.slice(0, 500)}`, url };
+  }
+  if (!text) return {};
+  return parseJsonSafe(text, text);
+}
+async function githubFetch(auth, path, init) {
+  return ghFetch(auth, path, init);
+}
+async function _ghFetch(auth, path, init) {
+  return ghFetch(auth, path, init);
+}
+var BODY_CAP = 2e4;
+var COMMENT_CAP = 8e3;
+var PATCH_CAP = 8e3;
+var SNIPPET_CAP = 400;
+function truncate(text, cap) {
+  if (text.length <= cap) return { text, truncated: false };
+  return { text: text.slice(0, cap), truncated: true };
+}
+function decodeContentsBlob(content, encoding) {
+  if (!content) return { binary: false, text: "", size_bytes: 0 };
+  const b64 = encoding === "base64" ? content.replace(/\s+/g, "") : "";
+  const buf = b64 ? Buffer.from(b64, "base64") : Buffer.from(content, "utf8");
+  if (isLikelyBinary(buf)) return { binary: true, size_bytes: buf.length };
+  return { binary: false, text: buf.toString("utf8"), size_bytes: buf.length };
+}
+function liteUser(u) {
+  return u?.login ?? null;
+}
+function liteLabels(labels) {
+  return (labels ?? []).map((l) => l.name).filter(Boolean);
+}
+var githubSearchIssuesTool = tools.tool(
+  async ({ q, repo, max_results }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const limit = Math.min(max_results ?? 25, 100);
+    const query = repo ? `repo:${repo} ${q}` : q;
+    const data = await ghFetch(
+      auth,
+      `/search/issues?q=${encodeURIComponent(query)}&per_page=${limit}`
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({
+      total: data.total_count ?? 0,
+      items: (data.items ?? []).map((i) => ({
+        number: i.number,
+        title: i.title,
+        state: i.state,
+        is_pr: !!i.pull_request,
+        url: i.html_url,
+        user: liteUser(i.user),
+        labels: liteLabels(i.labels),
+        updated_at: i.updated_at,
+        comments: i.comments ?? 0
+      }))
+    });
+  },
+  {
+    name: "github_search_issues",
+    description: "Search GitHub issues AND pull requests with the same query syntax as the github.com search bar. **PREFER THIS over shell-exec'ing the `gh` CLI.** Pass `repo` (\"owner/name\") to scope the search to a single repo \u2014 the tool prepends `repo:owner/name ` automatically. The `q` body accepts the full GitHub search vocabulary: 'is:issue is:open assignee:@me', 'is:pr review-requested:@me', 'label:bug created:>2026-01-01', etc. `is_pr` in the response distinguishes PRs from issues.",
+    schema: zod.z.object({
+      q: zod.z.string().describe("GitHub search query (e.g. 'is:open is:issue label:bug')"),
+      repo: zod.z.string().optional().describe("Optional 'owner/name' shortcut; prepended as repo: filter"),
+      max_results: zod.z.number().optional().describe("Max items (default 25, max 100)")
+    })
+  }
+);
+var githubGetIssueTool = tools.tool(
+  async ({ owner, repo, number }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${number}`
+    );
+    if (data.error) return JSON.stringify(data);
+    const assignees = (data.assignees ?? []).map((a) => a.login).filter(Boolean);
+    const cap = truncate(typeof data.body === "string" ? data.body : "", BODY_CAP);
+    return JSON.stringify({
+      number: data.number,
+      title: data.title,
+      state: data.state,
+      is_pr: !!data.pull_request,
+      url: data.html_url,
+      author: liteUser(data.user),
+      labels: liteLabels(data.labels),
+      assignees,
+      created_at: data.created_at,
+      updated_at: data.updated_at,
+      closed_at: data.closed_at,
+      comments: data.comments,
+      body: cap.text,
+      truncated: cap.truncated
+    });
+  },
+  {
+    name: "github_get_issue",
+    description: "Fetch a single issue (or PR \u2014 same endpoint) by number. Returns body capped at 20KB, plus labels, assignees, and timestamps. **PREFER THIS over shell-exec'ing the `gh` CLI.**",
+    schema: zod.z.object({
+      owner: zod.z.string().describe("Repository owner (user or org)"),
+      repo: zod.z.string().describe("Repository name"),
+      number: zod.z.number().int().positive().describe("Issue or PR number")
+    })
+  }
+);
+var githubCreateIssueTool = tools.tool(
+  async ({ owner, repo, title, body, labels, assignees }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const payload = { title };
+    if (body) payload.body = body;
+    if (labels?.length) payload.labels = labels;
+    if (assignees?.length) payload.assignees = assignees;
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues`,
+      { method: "POST", body: JSON.stringify(payload) }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({ ok: true, number: data.number, url: data.html_url });
+  },
+  {
+    name: "github_create_issue",
+    description: "Open a new issue in a repository. **PREFER THIS over shell-exec'ing the `gh` CLI.** Labels and assignees must already exist on the repo \u2014 invalid values produce a 422.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      title: zod.z.string().describe("Issue title"),
+      body: zod.z.string().optional().describe("Markdown body"),
+      labels: zod.z.array(zod.z.string()).optional().describe("Existing label names"),
+      assignees: zod.z.array(zod.z.string()).optional().describe("GitHub usernames with access")
+    })
+  }
+);
+var githubAddCommentTool = tools.tool(
+  async ({ owner, repo, number, body }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${number}/comments`,
+      { method: "POST", body: JSON.stringify({ body }) }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({ ok: true, comment_id: data.id, url: data.html_url });
+  },
+  {
+    name: "github_add_comment",
+    description: "Post a comment on an issue or pull request (GitHub treats both the same). **PREFER THIS over shell-exec'ing the `gh` CLI.** Body is rendered as GitHub-flavored Markdown.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      body: zod.z.string().describe("Comment body (GitHub-flavored Markdown)")
+    })
+  }
+);
+var githubListPullsTool = tools.tool(
+  async ({ owner, repo, state, head, base, max_results }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const limit = Math.min(max_results ?? 25, 100);
+    const params = new URLSearchParams({ per_page: String(limit) });
+    if (state) params.set("state", state);
+    if (head) params.set("head", head);
+    if (base) params.set("base", base);
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls?${params.toString()}`
+    );
+    if (!Array.isArray(data)) return JSON.stringify(data);
+    return JSON.stringify({
+      pulls: data.map((p) => ({
+        number: p.number,
+        title: p.title,
+        state: p.state,
+        draft: p.draft,
+        url: p.html_url,
+        user: liteUser(p.user),
+        head: p.head?.ref ?? null,
+        base: p.base?.ref ?? null,
+        created_at: p.created_at,
+        updated_at: p.updated_at
+      }))
+    });
+  },
+  {
+    name: "github_list_pulls",
+    description: "List pull requests for a repository, optionally filtered by state / head branch / base branch. **PREFER THIS over shell-exec'ing the `gh` CLI.** For richer detail on a single PR (mergeable, review state, file count) call github_get_pull.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      state: zod.z.enum(["open", "closed", "all"]).optional().describe("Default: open"),
+      head: zod.z.string().optional().describe("Filter by head: 'user:branch' or 'org:branch'"),
+      base: zod.z.string().optional().describe("Filter by base branch (e.g. 'main')"),
+      max_results: zod.z.number().optional().describe("Max PRs (default 25, max 100)")
+    })
+  }
+);
+var githubGetPullTool = tools.tool(
+  async ({ owner, repo, number }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}`
+    );
+    if (data.error) return JSON.stringify(data);
+    const head = data.head;
+    const base = data.base;
+    const cap = truncate(typeof data.body === "string" ? data.body : "", BODY_CAP);
+    return JSON.stringify({
+      number: data.number,
+      title: data.title,
+      state: data.state,
+      draft: data.draft,
+      merged: data.merged,
+      mergeable: data.mergeable,
+      // null = GitHub still computing
+      mergeable_state: data.mergeable_state,
+      url: data.html_url,
+      author: liteUser(data.user),
+      head: head ? { ref: head.ref, sha: head.sha, repo: head.repo?.full_name } : null,
+      base: base ? { ref: base.ref, sha: base.sha } : null,
+      changed_files: data.changed_files,
+      additions: data.additions,
+      deletions: data.deletions,
+      review_comments: data.review_comments,
+      comments: data.comments,
+      created_at: data.created_at,
+      updated_at: data.updated_at,
+      merged_at: data.merged_at,
+      body: cap.text,
+      truncated: cap.truncated
+    });
+  },
+  {
+    name: "github_get_pull",
+    description: "Fetch detail on a single pull request \u2014 head/base SHAs, mergeable state, additions/deletions, changed files count, review comment count. **PREFER THIS over shell-exec'ing the `gh` CLI.** Note: `mergeable` may be null on a freshly-pushed PR; GitHub computes it asynchronously.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive()
+    })
+  }
+);
+var githubGetRepoTool = tools.tool(
+  async ({ owner, repo }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({
+      full_name: data.full_name,
+      url: data.html_url,
+      description: data.description,
+      visibility: data.visibility ?? (data.private ? "private" : "public"),
+      default_branch: data.default_branch,
+      topics: data.topics ?? [],
+      language: data.language,
+      stars: data.stargazers_count,
+      forks: data.forks_count,
+      open_issues: data.open_issues_count,
+      archived: data.archived,
+      pushed_at: data.pushed_at
+    });
+  },
+  {
+    name: "github_get_repo",
+    description: "Fetch repo summary (default branch, visibility, description, topics, star/fork counts, open-issue count). **PREFER THIS over shell-exec'ing the `gh` CLI.** Useful before opening an issue (to confirm the repo exists / pick the right default branch).",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string()
+    })
+  }
+);
+var githubUpdateIssueTool = tools.tool(
+  async ({ owner, repo, number, title, body, state, state_reason, labels, assignees }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const payload = {};
+    if (title !== void 0) payload.title = title;
+    if (body !== void 0) payload.body = body;
+    if (state !== void 0) payload.state = state;
+    if (state_reason !== void 0) payload.state_reason = state_reason;
+    if (labels !== void 0) payload.labels = labels;
+    if (assignees !== void 0) payload.assignees = assignees;
+    if (Object.keys(payload).length === 0) {
+      return JSON.stringify({ error: "no fields to update \u2014 pass at least one of title/body/state/labels/assignees" });
+    }
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${number}`,
+      { method: "PATCH", body: JSON.stringify(payload) }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({
+      ok: true,
+      number: data.number,
+      state: data.state,
+      url: data.html_url,
+      updated_fields: Object.keys(payload)
+    });
+  },
+  {
+    name: "github_update_issue",
+    description: 'Edit an issue or PR (same endpoint): change title, body, labels, assignees, or close/reopen via `state`. **PREFER THIS over shell-exec\'ing the `gh` CLI.** Pass `state: "closed"` with `state_reason: "completed"` for done-as-intended, or `"not_planned"` for won\'t-fix.',
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      title: zod.z.string().optional(),
+      body: zod.z.string().optional().describe("New issue body (Markdown). Replaces, doesn't append."),
+      state: zod.z.enum(["open", "closed"]).optional(),
+      state_reason: zod.z.enum(["completed", "not_planned", "reopened"]).optional(),
+      labels: zod.z.array(zod.z.string()).optional().describe("Replaces the label set entirely."),
+      assignees: zod.z.array(zod.z.string()).optional().describe("Replaces the assignee set entirely.")
+    })
+  }
+);
+var githubListIssueCommentsTool = tools.tool(
+  async ({ owner, repo, number, max_results }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const limit = Math.min(max_results ?? 25, 100);
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${number}/comments?per_page=${limit}`
+    );
+    if (!Array.isArray(data)) return JSON.stringify(data);
+    return JSON.stringify({
+      comments: data.map((c) => {
+        const cap = truncate(typeof c.body === "string" ? c.body : "", COMMENT_CAP);
+        return {
+          id: c.id,
+          user: liteUser(c.user),
+          created_at: c.created_at,
+          updated_at: c.updated_at,
+          url: c.html_url,
+          body: cap.text,
+          truncated: cap.truncated
+        };
+      })
+    });
+  },
+  {
+    name: "github_list_issue_comments",
+    description: "List comments on an issue or PR. **PREFER THIS over shell-exec'ing the `gh` CLI.** Each comment body is capped at 8 KB; `truncated: true` flags ones that hit the cap.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      max_results: zod.z.number().optional().describe("Max comments (default 25, max 100)")
+    })
+  }
+);
+var githubCreatePullTool = tools.tool(
+  async ({ owner, repo, title, head, base, body, draft, maintainer_can_modify }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const payload = { title, head, base };
+    if (body !== void 0) payload.body = body;
+    if (draft !== void 0) payload.draft = draft;
+    if (maintainer_can_modify !== void 0) payload.maintainer_can_modify = maintainer_can_modify;
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls`,
+      { method: "POST", body: JSON.stringify(payload) }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({ ok: true, number: data.number, draft: data.draft, url: data.html_url });
+  },
+  {
+    name: "github_create_pull",
+    description: "Open a pull request. **PREFER THIS over shell-exec'ing the `gh` CLI.** `head` is the branch with your changes (use `user:branch` for cross-fork PRs); `base` is the branch you want to merge into. Returns 422 if the head/base pair has no diff or if the branches don't exist.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      title: zod.z.string(),
+      head: zod.z.string().describe("Source branch ('feature/x' for same-repo, 'user:branch' for fork PRs)"),
+      base: zod.z.string().describe("Target branch (typically 'main')"),
+      body: zod.z.string().optional().describe("PR description (Markdown)"),
+      draft: zod.z.boolean().optional().describe("Open as draft (default false)"),
+      maintainer_can_modify: zod.z.boolean().optional().describe("Allow upstream maintainers to push to your fork branch (default true)")
+    })
+  }
+);
+var githubUpdatePullTool = tools.tool(
+  async ({ owner, repo, number, title, body, state, base, maintainer_can_modify }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const payload = {};
+    if (title !== void 0) payload.title = title;
+    if (body !== void 0) payload.body = body;
+    if (state !== void 0) payload.state = state;
+    if (base !== void 0) payload.base = base;
+    if (maintainer_can_modify !== void 0) payload.maintainer_can_modify = maintainer_can_modify;
+    if (Object.keys(payload).length === 0) {
+      return JSON.stringify({ error: "no fields to update \u2014 pass at least one of title/body/state/base" });
+    }
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}`,
+      { method: "PATCH", body: JSON.stringify(payload) }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({
+      ok: true,
+      number: data.number,
+      state: data.state,
+      url: data.html_url,
+      updated_fields: Object.keys(payload)
+    });
+  },
+  {
+    name: "github_update_pull",
+    description: "Edit a pull request: title, body, base branch, or close/reopen. **PREFER THIS over shell-exec'ing the `gh` CLI.** To MERGE a PR use github_merge_pull \u2014 `state` here only opens / closes.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      title: zod.z.string().optional(),
+      body: zod.z.string().optional(),
+      state: zod.z.enum(["open", "closed"]).optional().describe("`closed` here means 'close without merging'. Use github_merge_pull to merge."),
+      base: zod.z.string().optional().describe("Re-target the PR at a different base branch."),
+      maintainer_can_modify: zod.z.boolean().optional()
+    })
+  }
+);
+var githubMergePullTool = tools.tool(
+  async ({ owner, repo, number, method, commit_title, commit_message, sha }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const payload = {};
+    if (commit_title !== void 0) payload.commit_title = commit_title;
+    if (commit_message !== void 0) payload.commit_message = commit_message;
+    if (method !== void 0) payload.merge_method = method;
+    if (sha !== void 0) payload.sha = sha;
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}/merge`,
+      { method: "PUT", body: JSON.stringify(payload) }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({
+      ok: !!data.merged,
+      merged_sha: data.sha ?? null,
+      message: data.message ?? null
+    });
+  },
+  {
+    name: "github_merge_pull",
+    description: "Merge a pull request. **PREFER THIS over shell-exec'ing the `gh` CLI.** `method` selects the merge strategy (default `merge`); pass `sha` to refuse the merge if the PR head has been force-pushed since you last looked. 405 means the PR isn't mergeable yet (still in CI / has conflicts / needs review); 409 means the `sha` guard tripped.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      method: zod.z.enum(["merge", "squash", "rebase"]).optional(),
+      commit_title: zod.z.string().optional().describe("Title for the merge commit (or squash commit). Default: GitHub's auto-generated title."),
+      commit_message: zod.z.string().optional(),
+      sha: zod.z.string().optional().describe("Refuse to merge unless the PR head still matches this SHA \u2014 guards against TOCTOU.")
+    })
+  }
+);
+var githubRequestReviewersTool = tools.tool(
+  async ({ owner, repo, number, reviewers, team_reviewers }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    if (!reviewers?.length && !team_reviewers?.length) {
+      return JSON.stringify({ error: "pass at least one of reviewers or team_reviewers" });
+    }
+    const payload = {};
+    if (reviewers?.length) payload.reviewers = reviewers;
+    if (team_reviewers?.length) payload.team_reviewers = team_reviewers;
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}/requested_reviewers`,
+      { method: "POST", body: JSON.stringify(payload) }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({
+      ok: true,
+      requested_users: (data.requested_reviewers ?? []).map((u) => u.login).filter(Boolean),
+      requested_teams: (data.requested_teams ?? []).map((t) => t.slug).filter(Boolean),
+      url: data.html_url
+    });
+  },
+  {
+    name: "github_request_reviewers",
+    description: "Request review on a pull request from one or more users and/or teams. **PREFER THIS over shell-exec'ing the `gh` CLI.** GitHub silently drops invalid usernames / team slugs \u2014 check the returned `requested_users` / `requested_teams` to see who actually got a notification.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      reviewers: zod.z.array(zod.z.string()).optional().describe("GitHub usernames"),
+      team_reviewers: zod.z.array(zod.z.string()).optional().describe("Team slugs (org-scoped)")
+    })
+  }
+);
+var githubCreateReviewTool = tools.tool(
+  async ({ owner, repo, number, event, body, commit_id }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    if (event === "REQUEST_CHANGES" && !body?.trim()) {
+      return JSON.stringify({ error: "REQUEST_CHANGES requires a non-empty body explaining what to change" });
+    }
+    const payload = { event };
+    if (body !== void 0) payload.body = body;
+    if (commit_id !== void 0) payload.commit_id = commit_id;
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}/reviews`,
+      { method: "POST", body: JSON.stringify(payload) }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({ ok: true, review_id: data.id, state: data.state, url: data.html_url });
+  },
+  {
+    name: "github_create_review",
+    description: "Submit a pull-request review (approve / request changes / leave a comment). **PREFER THIS over shell-exec'ing the `gh` CLI.** `event=APPROVE` doesn't require a body. `event=REQUEST_CHANGES` requires a body. Line-level inline review comments aren't supported by this tool yet \u2014 use the GitHub UI for those.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      event: zod.z.enum(["APPROVE", "REQUEST_CHANGES", "COMMENT"]),
+      body: zod.z.string().optional().describe("Review summary (Markdown). Required for REQUEST_CHANGES."),
+      commit_id: zod.z.string().optional().describe("Pin the review to a specific commit SHA.")
+    })
+  }
+);
+var githubListPullFilesTool = tools.tool(
+  async ({ owner, repo, number, max_results }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const limit = Math.min(max_results ?? 30, 100);
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}/files?per_page=${limit}`
+    );
+    if (!Array.isArray(data)) return JSON.stringify(data);
+    return JSON.stringify({
+      files: data.map((f) => {
+        const patch = typeof f.patch === "string" ? truncate(f.patch, PATCH_CAP) : null;
+        return {
+          filename: f.filename,
+          status: f.status,
+          // added | modified | removed | renamed | …
+          additions: f.additions,
+          deletions: f.deletions,
+          changes: f.changes,
+          previous_filename: f.previous_filename,
+          sha: f.sha,
+          patch: patch?.text,
+          patch_truncated: patch?.truncated ?? false
+        };
+      })
+    });
+  },
+  {
+    name: "github_list_pull_files",
+    description: "List files changed in a pull request, with per-file additions/deletions and (capped) patch text. **PREFER THIS over shell-exec'ing the `gh` CLI.** Each patch caps at 8 KB; `patch_truncated: true` means the diff was longer than that. GitHub itself caps the response at 3000 files.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      max_results: zod.z.number().optional().describe("Max files (default 30, max 100)")
+    })
+  }
+);
+var githubListPullReviewsTool = tools.tool(
+  async ({ owner, repo, number, max_results }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const limit = Math.min(max_results ?? 30, 100);
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}/reviews?per_page=${limit}`
+    );
+    if (!Array.isArray(data)) return JSON.stringify(data);
+    return JSON.stringify({
+      reviews: data.map((r) => {
+        const cap = truncate(typeof r.body === "string" ? r.body : "", COMMENT_CAP);
+        return {
+          id: r.id,
+          user: liteUser(r.user),
+          state: r.state,
+          // APPROVED | CHANGES_REQUESTED | COMMENTED | DISMISSED | PENDING
+          submitted_at: r.submitted_at,
+          commit_id: r.commit_id,
+          url: r.html_url,
+          body: cap.text,
+          truncated: cap.truncated
+        };
+      })
+    });
+  },
+  {
+    name: "github_list_pull_reviews",
+    description: "List reviews submitted on a pull request (approvals, change-requests, comment-only). **PREFER THIS over shell-exec'ing the `gh` CLI.** Use this to check whether a PR is approved before calling github_merge_pull.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      number: zod.z.number().int().positive(),
+      max_results: zod.z.number().optional().describe("Max reviews (default 30, max 100)")
+    })
+  }
+);
+var githubListBranchesTool = tools.tool(
+  async ({ owner, repo, max_results }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const limit = Math.min(max_results ?? 30, 100);
+    const data = await ghFetch(
+      auth,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/branches?per_page=${limit}`
+    );
+    if (!Array.isArray(data)) return JSON.stringify(data);
+    return JSON.stringify({
+      branches: data.map((b) => ({
+        name: b.name,
+        commit_sha: b.commit?.sha ?? null,
+        protected: b.protected
+      }))
+    });
+  },
+  {
+    name: "github_list_branches",
+    description: "List branches in a repository with their head SHAs and protection state. **PREFER THIS over shell-exec'ing the `gh` CLI.** Useful before opening a PR (confirm the head branch exists and is the SHA you expect).",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      max_results: zod.z.number().optional().describe("Max branches (default 30, max 100)")
+    })
+  }
+);
+var githubGetFileTool = tools.tool(
+  async ({ owner, repo, path, ref }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const url = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${path.split("/").map(encodeURIComponent).join("/")}` + (ref ? `?ref=${encodeURIComponent(ref)}` : "");
+    const data = await ghFetch(auth, url);
+    if (!Array.isArray(data) && data.error) {
+      return JSON.stringify(data);
+    }
+    if (Array.isArray(data) || data.type === "dir") {
+      return JSON.stringify({
+        error: `'${path}' is a directory; this tool only reads single files. Pass a path to a file.`
+      });
+    }
+    const f = data;
+    if (f.type !== "file") {
+      return JSON.stringify({ error: `unsupported content type '${f.type ?? "?"}' at ${path}` });
+    }
+    const decoded = decodeContentsBlob(f.content ?? "", f.encoding);
+    if (decoded.binary) {
+      return JSON.stringify({
+        path: f.path,
+        sha: f.sha,
+        url: f.html_url,
+        binary: true,
+        size_bytes: decoded.size_bytes
+      });
+    }
+    const cap = truncate(decoded.text ?? "", BODY_CAP);
+    return JSON.stringify({
+      path: f.path,
+      sha: f.sha,
+      url: f.html_url,
+      binary: false,
+      size_bytes: decoded.size_bytes,
+      content: cap.text,
+      truncated: cap.truncated
+    });
+  },
+  {
+    name: "github_get_file",
+    description: "Read a file's contents from a repo at an optional ref (branch / tag / commit SHA). **PREFER THIS over shell-exec'ing the `gh` CLI.** Returns up to 20 KB of UTF-8 text; longer files are truncated with `truncated: true`. Binary files return `binary: true` and `size_bytes` instead of `content`. GitHub itself rejects files larger than ~1 MB on this endpoint.",
+    schema: zod.z.object({
+      owner: zod.z.string(),
+      repo: zod.z.string(),
+      path: zod.z.string().describe("Path within the repo (e.g. 'src/lib/index.ts'). Slashes preserved."),
+      ref: zod.z.string().optional().describe("Branch, tag, or commit SHA. Default: repo's default branch.")
+    })
+  }
+);
+var githubSearchCodeTool = tools.tool(
+  async ({ q, repo, max_results }) => {
+    const auth = resolveAuth();
+    if ("error" in auth) return JSON.stringify({ error: auth.error });
+    const limit = Math.min(max_results ?? 25, 100);
+    const query = repo ? `repo:${repo} ${q}` : q;
+    const data = await ghFetch(
+      auth,
+      `/search/code?q=${encodeURIComponent(query)}&per_page=${limit}`,
+      { headers: { Accept: "application/vnd.github.text-match+json" } }
+    );
+    if (data.error) return JSON.stringify(data);
+    return JSON.stringify({
+      total: data.total_count ?? 0,
+      items: (data.items ?? []).map((i) => {
+        const fragment = i.text_matches?.[0]?.fragment ?? "";
+        const snip = truncate(fragment, SNIPPET_CAP);
+        return {
+          name: i.name,
+          path: i.path,
+          repo: i.repository?.full_name,
+          url: i.html_url,
+          sha: i.sha,
+          snippet: snip.text,
+          snippet_truncated: snip.truncated
+        };
+      })
+    });
+  },
+  {
+    name: "github_search_code",
+    description: "Search file contents across GitHub. **PREFER THIS over shell-exec'ing the `gh` CLI.** Pass `repo` (\"owner/name\") to scope to one repo; the tool prepends `repo:owner/name `. The `q` body accepts GitHub's full code-search syntax: 'language:ts symbolName', 'extension:py path:tests assert', etc. Each hit returns a 400-char snippet around the match. Note: GitHub code search has stricter rate limits than other endpoints (10/min for unauthenticated, 30/min for authenticated).",
+    schema: zod.z.object({
+      q: zod.z.string().describe("Code search query (e.g. 'language:ts isLikelyBinary')"),
+      repo: zod.z.string().optional().describe("Optional 'owner/name' shortcut; prepended as repo: filter"),
+      max_results: zod.z.number().optional().describe("Max items (default 25, max 100)")
+    })
+  }
+);
+var githubReadTools = [
+  // Issues — read
+  githubSearchIssuesTool,
+  githubGetIssueTool,
+  githubListIssueCommentsTool,
+  // Pull requests — read
+  githubListPullsTool,
+  githubGetPullTool,
+  githubListPullFilesTool,
+  githubListPullReviewsTool,
+  // Repo content
+  githubGetRepoTool,
+  githubListBranchesTool,
+  githubGetFileTool,
+  githubSearchCodeTool
+];
+var githubWriteTools = [
+  // Issues
+  githubCreateIssueTool,
+  githubUpdateIssueTool,
+  githubAddCommentTool,
+  // Pull requests (record edits — open/update/review)
+  githubCreatePullTool,
+  githubUpdatePullTool,
+  githubRequestReviewersTool,
+  githubCreateReviewTool
+];
+var githubExecuteTools = [githubMergePullTool];
+var githubTools = [
+  ...githubReadTools,
+  ...githubWriteTools,
+  ...githubExecuteTools
+];
+
+exports._ghFetch = _ghFetch;
+exports._resolveGithubAuth = _resolveGithubAuth;
+exports.decodeContentsBlob = decodeContentsBlob;
+exports.githubAddCommentTool = githubAddCommentTool;
+exports.githubCreateIssueTool = githubCreateIssueTool;
+exports.githubCreatePullTool = githubCreatePullTool;
+exports.githubCreateReviewTool = githubCreateReviewTool;
+exports.githubExecuteTools = githubExecuteTools;
+exports.githubFetch = githubFetch;
+exports.githubGetFileTool = githubGetFileTool;
+exports.githubGetIssueTool = githubGetIssueTool;
+exports.githubGetPullTool = githubGetPullTool;
+exports.githubGetRepoTool = githubGetRepoTool;
+exports.githubListBranchesTool = githubListBranchesTool;
+exports.githubListIssueCommentsTool = githubListIssueCommentsTool;
+exports.githubListPullFilesTool = githubListPullFilesTool;
+exports.githubListPullReviewsTool = githubListPullReviewsTool;
+exports.githubListPullsTool = githubListPullsTool;
+exports.githubMergePullTool = githubMergePullTool;
+exports.githubReadTools = githubReadTools;
+exports.githubRequestReviewersTool = githubRequestReviewersTool;
+exports.githubSearchCodeTool = githubSearchCodeTool;
+exports.githubSearchIssuesTool = githubSearchIssuesTool;
+exports.githubTools = githubTools;
+exports.githubUpdateIssueTool = githubUpdateIssueTool;
+exports.githubUpdatePullTool = githubUpdatePullTool;
+exports.githubWriteTools = githubWriteTools;
+exports.resolveGithubAuthFromEnv = resolveGithubAuthFromEnv;
+exports.setAuthResolver = setAuthResolver;
+exports.truncate = truncate;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map