@github-tools/sdk 1.2.0 → 1.3.0

package/dist/agents-Cdb0a8CP.mjs

@@ -0,0 +1,1455 @@
+import { createGithubTools } from "./index.mjs";
+import { ToolLoopAgent, tool } from "ai";
+import { z } from "zod";
+import { Octokit } from "octokit";
+
+//#region src/client.ts
+function createOctokit(token) {
+	return new Octokit({ auth: token });
+}
+
+//#endregion
+//#region src/tools/repository.ts
+async function getRepositoryStep({ token, owner, repo }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.repos.get({
+		owner,
+		repo
+	});
+	return {
+		name: data.name,
+		fullName: data.full_name,
+		description: data.description,
+		url: data.html_url,
+		defaultBranch: data.default_branch,
+		stars: data.stargazers_count,
+		forks: data.forks_count,
+		openIssues: data.open_issues_count,
+		language: data.language,
+		private: data.private,
+		createdAt: data.created_at,
+		updatedAt: data.updated_at
+	};
+}
+const getRepository = (token) => tool({
+	description: "Get information about a GitHub repository including description, stars, forks, language, and default branch",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner (user or organization)"),
+		repo: z.string().describe("Repository name")
+	}),
+	execute: async (args) => getRepositoryStep({
+		token,
+		...args
+	})
+});
+async function listBranchesStep({ token, owner, repo, perPage }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.repos.listBranches({
+		owner,
+		repo,
+		per_page: perPage
+	});
+	return data.map((branch) => ({
+		name: branch.name,
+		sha: branch.commit.sha,
+		protected: branch.protected
+	}));
+}
+const listBranches = (token) => tool({
+	description: "List branches in a GitHub repository",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		perPage: z.number().optional().default(30).describe("Number of branches to return (max 100)")
+	}),
+	execute: async (args) => listBranchesStep({
+		token,
+		...args
+	})
+});
+async function getFileContentStep({ token, owner, repo, path, ref }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.repos.getContent({
+		owner,
+		repo,
+		path,
+		ref
+	});
+	if (Array.isArray(data)) return {
+		type: "directory",
+		entries: data.map((e) => ({
+			name: e.name,
+			type: e.type,
+			path: e.path
+		}))
+	};
+	if (data.type !== "file") return {
+		type: data.type,
+		path: data.path
+	};
+	const content = Buffer.from(data.content, "base64").toString("utf-8");
+	return {
+		type: "file",
+		path: data.path,
+		sha: data.sha,
+		size: data.size,
+		content
+	};
+}
+const getFileContent = (token) => tool({
+	description: "Get the content of a file from a GitHub repository",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		path: z.string().describe("Path to the file in the repository"),
+		ref: z.string().optional().describe("Branch, tag, or commit SHA (defaults to the default branch)")
+	}),
+	execute: async (args) => getFileContentStep({
+		token,
+		...args
+	})
+});
+async function createBranchStep({ token, owner, repo, branch, from }) {
+	"use step";
+	const octokit = createOctokit(token);
+	let sha = from;
+	if (!sha || !sha.match(/^[0-9a-f]{40}$/i)) {
+		const { data: ref } = await octokit.rest.git.getRef({
+			owner,
+			repo,
+			ref: `heads/${from || (await octokit.rest.repos.get({
+				owner,
+				repo
+			})).data.default_branch}`
+		});
+		sha = ref.object.sha;
+	}
+	const { data } = await octokit.rest.git.createRef({
+		owner,
+		repo,
+		ref: `refs/heads/${branch}`,
+		sha
+	});
+	return {
+		ref: data.ref,
+		sha: data.object.sha,
+		url: data.url
+	};
+}
+const createBranch = (token, { needsApproval = true } = {}) => tool({
+	description: "Create a new branch in a GitHub repository from an existing branch or commit SHA",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		branch: z.string().describe("Name for the new branch"),
+		from: z.string().optional().describe("Source branch name or commit SHA to branch from (defaults to the default branch)")
+	}),
+	execute: async (args) => createBranchStep({
+		token,
+		...args
+	})
+});
+async function forkRepositoryStep({ token, owner, repo, organization, name }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.repos.createFork({
+		owner,
+		repo,
+		organization,
+		name
+	});
+	return {
+		name: data.name,
+		fullName: data.full_name,
+		url: data.html_url,
+		cloneUrl: data.clone_url,
+		sshUrl: data.ssh_url,
+		defaultBranch: data.default_branch,
+		private: data.private,
+		parent: data.parent ? {
+			fullName: data.parent.full_name,
+			url: data.parent.html_url
+		} : null
+	};
+}
+const forkRepository = (token, { needsApproval = true } = {}) => tool({
+	description: "Fork a GitHub repository to the authenticated user account or a specified organization",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner to fork from"),
+		repo: z.string().describe("Repository name to fork"),
+		organization: z.string().optional().describe("Organization to fork into (omit to fork to your personal account)"),
+		name: z.string().optional().describe("Name for the forked repository (defaults to the original name)")
+	}),
+	execute: async (args) => forkRepositoryStep({
+		token,
+		...args
+	})
+});
+async function createRepositoryStep({ token, name, description, isPrivate, autoInit, gitignoreTemplate, licenseTemplate, org }) {
+	"use step";
+	const octokit = createOctokit(token);
+	const params = {
+		name,
+		description,
+		private: isPrivate,
+		auto_init: autoInit,
+		gitignore_template: gitignoreTemplate,
+		license_template: licenseTemplate
+	};
+	const { data } = org ? await octokit.rest.repos.createInOrg({
+		org,
+		...params
+	}) : await octokit.rest.repos.createForAuthenticatedUser(params);
+	return {
+		name: data.name,
+		fullName: data.full_name,
+		description: data.description,
+		url: data.html_url,
+		cloneUrl: data.clone_url,
+		sshUrl: data.ssh_url,
+		defaultBranch: data.default_branch,
+		private: data.private,
+		createdAt: data.created_at
+	};
+}
+const createRepository = (token, { needsApproval = true } = {}) => tool({
+	description: "Create a new GitHub repository for the authenticated user or a specified organization",
+	needsApproval,
+	inputSchema: z.object({
+		name: z.string().describe("Repository name"),
+		description: z.string().optional().describe("A short description of the repository"),
+		isPrivate: z.boolean().optional().default(false).describe("Whether the repository is private"),
+		autoInit: z.boolean().optional().default(false).describe("Create an initial commit with a README"),
+		gitignoreTemplate: z.string().optional().describe("Gitignore template to use (e.g. \"Node\", \"Python\")"),
+		licenseTemplate: z.string().optional().describe("License keyword (e.g. \"mit\", \"apache-2.0\")"),
+		org: z.string().optional().describe("Organization to create the repository in (omit for personal repo)")
+	}),
+	execute: async (args) => createRepositoryStep({
+		token,
+		...args
+	})
+});
+async function createOrUpdateFileStep({ token, owner, repo, path, message, content, branch, sha }) {
+	"use step";
+	const octokit = createOctokit(token);
+	const encoded = Buffer.from(content).toString("base64");
+	const { data } = await octokit.rest.repos.createOrUpdateFileContents({
+		owner,
+		repo,
+		path,
+		message,
+		content: encoded,
+		branch,
+		sha
+	});
+	return {
+		path: data.content?.path,
+		sha: data.content?.sha,
+		commitSha: data.commit.sha,
+		commitUrl: data.commit.html_url
+	};
+}
+const createOrUpdateFile = (token, { needsApproval = true } = {}) => tool({
+	description: "Create or update a file in a GitHub repository. Provide the SHA when updating an existing file.",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		path: z.string().describe("Path to the file in the repository"),
+		message: z.string().describe("Commit message"),
+		content: z.string().describe("File content (plain text, will be base64-encoded automatically)"),
+		branch: z.string().optional().describe("Branch to commit to (defaults to the default branch)"),
+		sha: z.string().optional().describe("SHA of the file being replaced (required when updating an existing file)")
+	}),
+	execute: async (args) => createOrUpdateFileStep({
+		token,
+		...args
+	})
+});
+
+//#endregion
+//#region src/tools/pull-requests.ts
+async function listPullRequestsStep({ token, owner, repo, state, perPage }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.pulls.list({
+		owner,
+		repo,
+		state,
+		per_page: perPage
+	});
+	return data.map((pr) => ({
+		number: pr.number,
+		title: pr.title,
+		state: pr.state,
+		url: pr.html_url,
+		author: pr.user?.login,
+		branch: pr.head.ref,
+		base: pr.base.ref,
+		draft: pr.draft,
+		createdAt: pr.created_at,
+		updatedAt: pr.updated_at
+	}));
+}
+const listPullRequests = (token) => tool({
+	description: "List pull requests for a GitHub repository",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		state: z.enum([
+			"open",
+			"closed",
+			"all"
+		]).optional().default("open").describe("Filter by state"),
+		perPage: z.number().optional().default(30).describe("Number of results to return (max 100)")
+	}),
+	execute: async (args) => listPullRequestsStep({
+		token,
+		...args
+	})
+});
+async function getPullRequestStep({ token, owner, repo, pullNumber }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.pulls.get({
+		owner,
+		repo,
+		pull_number: pullNumber
+	});
+	return {
+		number: data.number,
+		title: data.title,
+		body: data.body,
+		state: data.state,
+		url: data.html_url,
+		author: data.user?.login,
+		branch: data.head.ref,
+		base: data.base.ref,
+		draft: data.draft,
+		merged: data.merged,
+		mergeable: data.mergeable,
+		additions: data.additions,
+		deletions: data.deletions,
+		changedFiles: data.changed_files,
+		createdAt: data.created_at,
+		updatedAt: data.updated_at,
+		mergedAt: data.merged_at
+	};
+}
+const getPullRequest = (token) => tool({
+	description: "Get detailed information about a specific pull request",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		pullNumber: z.number().describe("Pull request number")
+	}),
+	execute: async (args) => getPullRequestStep({
+		token,
+		...args
+	})
+});
+async function createPullRequestStep({ token, owner, repo, title, body, head, base, draft }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.pulls.create({
+		owner,
+		repo,
+		title,
+		body,
+		head,
+		base,
+		draft
+	});
+	return {
+		number: data.number,
+		title: data.title,
+		url: data.html_url,
+		state: data.state,
+		draft: data.draft,
+		branch: data.head.ref,
+		base: data.base.ref
+	};
+}
+const createPullRequest = (token, { needsApproval = true } = {}) => tool({
+	description: "Create a new pull request in a GitHub repository",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		title: z.string().describe("Pull request title"),
+		body: z.string().optional().describe("Pull request description (supports Markdown)"),
+		head: z.string().describe("Branch containing the changes (format: branch or username:branch)"),
+		base: z.string().describe("Branch to merge into"),
+		draft: z.boolean().optional().default(false).describe("Create as draft pull request")
+	}),
+	execute: async (args) => createPullRequestStep({
+		token,
+		...args
+	})
+});
+async function mergePullRequestStep({ token, owner, repo, pullNumber, commitTitle, commitMessage, mergeMethod }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.pulls.merge({
+		owner,
+		repo,
+		pull_number: pullNumber,
+		commit_title: commitTitle,
+		commit_message: commitMessage,
+		merge_method: mergeMethod
+	});
+	return {
+		merged: data.merged,
+		message: data.message,
+		sha: data.sha
+	};
+}
+const mergePullRequest = (token, { needsApproval = true } = {}) => tool({
+	description: "Merge a pull request",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		pullNumber: z.number().describe("Pull request number"),
+		commitTitle: z.string().optional().describe("Title for the automatic merge commit"),
+		commitMessage: z.string().optional().describe("Extra detail to append to automatic commit message"),
+		mergeMethod: z.enum([
+			"merge",
+			"squash",
+			"rebase"
+		]).optional().default("merge").describe("Merge strategy")
+	}),
+	execute: async (args) => mergePullRequestStep({
+		token,
+		...args
+	})
+});
+async function addPullRequestCommentStep({ token, owner, repo, pullNumber, body }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.issues.createComment({
+		owner,
+		repo,
+		issue_number: pullNumber,
+		body
+	});
+	return {
+		id: data.id,
+		url: data.html_url,
+		body: data.body,
+		author: data.user?.login,
+		createdAt: data.created_at
+	};
+}
+const addPullRequestComment = (token, { needsApproval = true } = {}) => tool({
+	description: "Add a comment to a pull request",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		pullNumber: z.number().describe("Pull request number"),
+		body: z.string().describe("Comment text (supports Markdown)")
+	}),
+	execute: async (args) => addPullRequestCommentStep({
+		token,
+		...args
+	})
+});
+
+//#endregion
+//#region src/tools/issues.ts
+async function listIssuesStep({ token, owner, repo, state, labels, perPage }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.issues.listForRepo({
+		owner,
+		repo,
+		state,
+		labels,
+		per_page: perPage
+	});
+	return data.filter((issue) => !issue.pull_request).map((issue) => ({
+		number: issue.number,
+		title: issue.title,
+		state: issue.state,
+		url: issue.html_url,
+		author: issue.user?.login,
+		labels: issue.labels.map((l) => typeof l === "string" ? l : l.name),
+		createdAt: issue.created_at,
+		updatedAt: issue.updated_at
+	}));
+}
+const listIssues = (token) => tool({
+	description: "List issues for a GitHub repository (excludes pull requests)",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		state: z.enum([
+			"open",
+			"closed",
+			"all"
+		]).optional().default("open").describe("Filter by state"),
+		labels: z.string().optional().describe("Comma-separated list of label names to filter by"),
+		perPage: z.number().optional().default(30).describe("Number of results to return (max 100)")
+	}),
+	execute: async (args) => listIssuesStep({
+		token,
+		...args
+	})
+});
+async function getIssueStep({ token, owner, repo, issueNumber }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.issues.get({
+		owner,
+		repo,
+		issue_number: issueNumber
+	});
+	return {
+		number: data.number,
+		title: data.title,
+		body: data.body,
+		state: data.state,
+		url: data.html_url,
+		author: data.user?.login,
+		assignees: data.assignees?.map((a) => a.login),
+		labels: data.labels.map((l) => typeof l === "string" ? l : l.name),
+		comments: data.comments,
+		createdAt: data.created_at,
+		updatedAt: data.updated_at,
+		closedAt: data.closed_at
+	};
+}
+const getIssue = (token) => tool({
+	description: "Get detailed information about a specific issue",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		issueNumber: z.number().describe("Issue number")
+	}),
+	execute: async (args) => getIssueStep({
+		token,
+		...args
+	})
+});
+async function createIssueStep({ token, owner, repo, title, body, labels, assignees }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.issues.create({
+		owner,
+		repo,
+		title,
+		body,
+		labels,
+		assignees
+	});
+	return {
+		number: data.number,
+		title: data.title,
+		url: data.html_url,
+		state: data.state,
+		labels: data.labels.map((l) => typeof l === "string" ? l : l.name)
+	};
+}
+const createIssue = (token, { needsApproval = true } = {}) => tool({
+	description: "Create a new issue in a GitHub repository",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		title: z.string().describe("Issue title"),
+		body: z.string().optional().describe("Issue description (supports Markdown)"),
+		labels: z.array(z.string()).optional().describe("Labels to apply to the issue"),
+		assignees: z.array(z.string()).optional().describe("GitHub usernames to assign to the issue")
+	}),
+	execute: async (args) => createIssueStep({
+		token,
+		...args
+	})
+});
+async function addIssueCommentStep({ token, owner, repo, issueNumber, body }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.issues.createComment({
+		owner,
+		repo,
+		issue_number: issueNumber,
+		body
+	});
+	return {
+		id: data.id,
+		url: data.html_url,
+		body: data.body,
+		author: data.user?.login,
+		createdAt: data.created_at
+	};
+}
+const addIssueComment = (token, { needsApproval = true } = {}) => tool({
+	description: "Add a comment to a GitHub issue",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		issueNumber: z.number().describe("Issue number"),
+		body: z.string().describe("Comment text (supports Markdown)")
+	}),
+	execute: async (args) => addIssueCommentStep({
+		token,
+		...args
+	})
+});
+async function closeIssueStep({ token, owner, repo, issueNumber, stateReason }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.issues.update({
+		owner,
+		repo,
+		issue_number: issueNumber,
+		state: "closed",
+		state_reason: stateReason
+	});
+	return {
+		number: data.number,
+		title: data.title,
+		state: data.state,
+		url: data.html_url,
+		closedAt: data.closed_at
+	};
+}
+const closeIssue = (token, { needsApproval = true } = {}) => tool({
+	description: "Close an open GitHub issue",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		issueNumber: z.number().describe("Issue number to close"),
+		stateReason: z.enum(["completed", "not_planned"]).optional().default("completed").describe("Reason for closing")
+	}),
+	execute: async (args) => closeIssueStep({
+		token,
+		...args
+	})
+});
+
+//#endregion
+//#region src/tools/search.ts
+async function searchCodeStep({ token, query, perPage }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.search.code({
+		q: query,
+		per_page: perPage
+	});
+	return {
+		totalCount: data.total_count,
+		items: data.items.map((item) => ({
+			name: item.name,
+			path: item.path,
+			url: item.html_url,
+			repository: item.repository.full_name,
+			sha: item.sha
+		}))
+	};
+}
+const searchCode = (token) => tool({
+	description: "Search for code in GitHub repositories. Use qualifiers like \"repo:owner/name\" to scope the search.",
+	inputSchema: z.object({
+		query: z.string().describe("Search query. Supports GitHub search qualifiers, e.g. \"useState repo:facebook/react\""),
+		perPage: z.number().optional().default(10).describe("Number of results to return (max 30)")
+	}),
+	execute: async (args) => searchCodeStep({
+		token,
+		...args
+	})
+});
+async function searchRepositoriesStep({ token, query, perPage, sort, order }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.search.repos({
+		q: query,
+		per_page: perPage,
+		sort,
+		order
+	});
+	return {
+		totalCount: data.total_count,
+		items: data.items.map((repo) => ({
+			name: repo.name,
+			fullName: repo.full_name,
+			description: repo.description,
+			url: repo.html_url,
+			stars: repo.stargazers_count,
+			forks: repo.forks_count,
+			language: repo.language,
+			topics: repo.topics
+		}))
+	};
+}
+const searchRepositories = (token) => tool({
+	description: "Search for GitHub repositories by keyword, topic, language, or other qualifiers",
+	inputSchema: z.object({
+		query: z.string().describe("Search query. Supports GitHub search qualifiers, e.g. \"nuxt language:typescript stars:>1000\""),
+		perPage: z.number().optional().default(10).describe("Number of results to return (max 30)"),
+		sort: z.enum([
+			"stars",
+			"forks",
+			"help-wanted-issues",
+			"updated"
+		]).optional().describe("Sort field"),
+		order: z.enum(["asc", "desc"]).optional().default("desc").describe("Sort order")
+	}),
+	execute: async (args) => searchRepositoriesStep({
+		token,
+		...args
+	})
+});
+
+//#endregion
+//#region src/tools/commits.ts
+const BLAME_QUERY = `
+  query ($owner: String!, $name: String!, $expression: String!, $path: String!) {
+    repository(owner: $owner, name: $name) {
+      object(expression: $expression) {
+        ... on Commit {
+          oid
+          blame(path: $path) {
+            ranges {
+              startingLine
+              endingLine
+              age
+              commit {
+                oid
+                abbreviatedOid
+                messageHeadline
+                authoredDate
+                url
+                author {
+                  name
+                  email
+                  user {
+                    login
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+async function listCommitsStep({ token, owner, repo, path, sha, author, since, until, perPage }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.repos.listCommits({
+		owner,
+		repo,
+		path,
+		sha,
+		author,
+		since,
+		until,
+		per_page: perPage
+	});
+	return data.map((commit) => ({
+		sha: commit.sha,
+		message: commit.commit.message,
+		author: commit.commit.author?.name,
+		authorLogin: commit.author?.login,
+		date: commit.commit.author?.date,
+		url: commit.html_url
+	}));
+}
+const listCommits = (token) => tool({
+	description: "List commits for a GitHub repository. Filter by file path to see commits that touched a file. For line-by-line attribution at a given ref, use getBlame instead.",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		path: z.string().optional().describe("Only commits containing this file path"),
+		sha: z.string().optional().describe("Branch name or commit SHA to start listing from"),
+		author: z.string().optional().describe("GitHub username or email to filter commits by"),
+		since: z.string().optional().describe("Only commits after this date (ISO 8601 format)"),
+		until: z.string().optional().describe("Only commits before this date (ISO 8601 format)"),
+		perPage: z.number().optional().default(30).describe("Number of results to return (max 100)")
+	}),
+	execute: async (args) => listCommitsStep({
+		token,
+		...args
+	})
+});
+async function getCommitStep({ token, owner, repo, ref }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.repos.getCommit({
+		owner,
+		repo,
+		ref
+	});
+	return {
+		sha: data.sha,
+		message: data.commit.message,
+		author: data.commit.author?.name,
+		authorLogin: data.author?.login,
+		date: data.commit.author?.date,
+		url: data.html_url,
+		stats: data.stats ? {
+			additions: data.stats.additions,
+			deletions: data.stats.deletions,
+			total: data.stats.total
+		} : null,
+		files: data.files?.map((file) => ({
+			filename: file.filename,
+			status: file.status,
+			additions: file.additions,
+			deletions: file.deletions,
+			patch: file.patch
+		}))
+	};
+}
+const getCommit = (token) => tool({
+	description: "Get detailed information about a specific commit, including the list of files changed with additions and deletions",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		ref: z.string().describe("Commit SHA, branch name, or tag")
+	}),
+	execute: async (args) => getCommitStep({
+		token,
+		...args
+	})
+});
+async function getBlameStep({ token, owner, repo, path, ref, line, lineStart, lineEnd }) {
+	"use step";
+	const octokit = createOctokit(token);
+	let expression = ref;
+	if (!expression) {
+		const { data } = await octokit.rest.repos.get({
+			owner,
+			repo
+		});
+		expression = data.default_branch;
+	}
+	const data = await octokit.graphql(BLAME_QUERY, {
+		owner,
+		name: repo,
+		expression,
+		path
+	});
+	if (!data.repository) return { error: `Repository not found: ${owner}/${repo}` };
+	const obj = data.repository.object;
+	if (!obj?.oid || !obj?.blame) return { error: `Ref "${expression}" did not resolve to a commit for this repository (or the path is invalid). Pass a branch name, tag, or full commit SHA.` };
+	let ranges = obj.blame.ranges.map((r) => ({
+		startingLine: r.startingLine,
+		endingLine: r.endingLine,
+		age: r.age,
+		commit: {
+			sha: r.commit.oid,
+			abbreviatedSha: r.commit.abbreviatedOid,
+			messageHeadline: r.commit.messageHeadline,
+			authoredDate: r.commit.authoredDate,
+			url: r.commit.url,
+			authorName: r.commit.author?.name ?? null,
+			authorEmail: r.commit.author?.email ?? null,
+			authorLogin: r.commit.author?.user?.login ?? null
+		}
+	}));
+	if (line != null) ranges = ranges.filter((r) => line >= r.startingLine && line <= r.endingLine);
+	else if (lineStart != null || lineEnd != null) {
+		const start = lineStart ?? 1;
+		const end = lineEnd ?? Number.MAX_SAFE_INTEGER;
+		ranges = ranges.filter((r) => r.endingLine >= start && r.startingLine <= end);
+	}
+	return {
+		ref: expression,
+		tipSha: obj.oid,
+		path,
+		rangeCount: ranges.length,
+		ranges
+	};
+}
+const getBlame = (token) => tool({
+	description: "Line-level git blame for a file at a commit-like ref (branch, tag, or SHA). Returns contiguous ranges mapping lines to the commits that last modified them — use this to see who introduced a line and when (GitHub GraphQL API).",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		path: z.string().describe("Path to the file in the repository"),
+		ref: z.string().optional().describe("Branch name, tag, or commit SHA (defaults to the repository default branch)"),
+		line: z.number().int().positive().optional().describe("If set, only return blame ranges that include this line number"),
+		lineStart: z.number().int().positive().optional().describe("When used with lineEnd, only return ranges overlapping this window"),
+		lineEnd: z.number().int().positive().optional().describe("When used with lineStart, only return ranges overlapping this window")
+	}),
+	execute: async (args) => getBlameStep({
+		token,
+		...args
+	})
+});
+
+//#endregion
+//#region src/tools/gists.ts
+async function listGistsStep({ token, username, perPage, page }) {
+	"use step";
+	const octokit = createOctokit(token);
+	const { data } = username ? await octokit.rest.gists.listForUser({
+		username,
+		per_page: perPage,
+		page
+	}) : await octokit.rest.gists.list({
+		per_page: perPage,
+		page
+	});
+	return data.map((gist) => ({
+		id: gist.id,
+		description: gist.description,
+		public: gist.public,
+		url: gist.html_url,
+		files: Object.keys(gist.files ?? {}),
+		owner: gist.owner?.login,
+		comments: gist.comments,
+		createdAt: gist.created_at,
+		updatedAt: gist.updated_at
+	}));
+}
+const listGists = (token) => tool({
+	description: "List gists for the authenticated user or a specific user",
+	inputSchema: z.object({
+		username: z.string().optional().describe("GitHub username — omit to list your own gists"),
+		perPage: z.number().optional().default(30).describe("Number of results to return (max 100)"),
+		page: z.number().optional().default(1).describe("Page number for pagination")
+	}),
+	execute: async (args) => listGistsStep({
+		token,
+		...args
+	})
+});
+async function getGistStep({ token, gistId }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.gists.get({ gist_id: gistId });
+	return {
+		id: data.id,
+		description: data.description,
+		public: data.public,
+		url: data.html_url,
+		owner: data.owner?.login,
+		files: Object.values(data.files ?? {}).map((file) => ({
+			filename: file?.filename,
+			language: file?.language,
+			size: file?.size,
+			content: file?.content
+		})),
+		comments: data.comments,
+		createdAt: data.created_at,
+		updatedAt: data.updated_at
+	};
+}
+const getGist = (token) => tool({
+	description: "Get a gist by ID, including file contents",
+	inputSchema: z.object({ gistId: z.string().describe("Gist ID") }),
+	execute: async (args) => getGistStep({
+		token,
+		...args
+	})
+});
+async function listGistCommentsStep({ token, gistId, perPage, page }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.gists.listComments({
+		gist_id: gistId,
+		per_page: perPage,
+		page
+	});
+	return data.map((comment) => ({
+		id: comment.id,
+		body: comment.body,
+		author: comment.user?.login,
+		url: comment.url,
+		createdAt: comment.created_at,
+		updatedAt: comment.updated_at
+	}));
+}
+const listGistComments = (token) => tool({
+	description: "List comments on a gist",
+	inputSchema: z.object({
+		gistId: z.string().describe("Gist ID"),
+		perPage: z.number().optional().default(30).describe("Number of results to return (max 100)"),
+		page: z.number().optional().default(1).describe("Page number for pagination")
+	}),
+	execute: async (args) => listGistCommentsStep({
+		token,
+		...args
+	})
+});
+async function createGistStep({ token, description, files, isPublic }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.gists.create({
+		description,
+		files,
+		public: isPublic
+	});
+	return {
+		id: data.id,
+		description: data.description,
+		public: data.public,
+		url: data.html_url,
+		files: Object.keys(data.files ?? {}),
+		owner: data.owner?.login
+	};
+}
+const createGist = (token, { needsApproval = true } = {}) => tool({
+	description: "Create a new gist with one or more files",
+	needsApproval,
+	inputSchema: z.object({
+		description: z.string().optional().describe("Gist description"),
+		files: z.record(z.string(), z.object({ content: z.string().describe("File content") })).describe("Files to include, keyed by filename"),
+		isPublic: z.boolean().optional().default(false).describe("Whether the gist is public")
+	}),
+	execute: async (args) => createGistStep({
+		token,
+		...args
+	})
+});
+async function updateGistStep({ token, gistId, description, files, filesToDelete }) {
+	"use step";
+	const octokit = createOctokit(token);
+	const fileUpdates = {};
+	if (files) Object.assign(fileUpdates, files);
+	if (filesToDelete) for (const name of filesToDelete) fileUpdates[name] = null;
+	const { data } = await octokit.rest.gists.update({
+		gist_id: gistId,
+		description,
+		files: fileUpdates
+	});
+	return {
+		id: data.id,
+		description: data.description,
+		url: data.html_url,
+		files: Object.keys(data.files ?? {})
+	};
+}
+const updateGist = (token, { needsApproval = true } = {}) => tool({
+	description: "Update an existing gist — edit description, update files, or remove files",
+	needsApproval,
+	inputSchema: z.object({
+		gistId: z.string().describe("Gist ID"),
+		description: z.string().optional().describe("New gist description"),
+		files: z.record(z.string(), z.object({ content: z.string().describe("New file content") })).optional().describe("Files to add or update, keyed by filename"),
+		filesToDelete: z.array(z.string()).optional().describe("Filenames to remove from the gist")
+	}),
+	execute: async (args) => updateGistStep({
+		token,
+		...args
+	})
+});
+async function deleteGistStep({ token, gistId }) {
+	"use step";
+	await createOctokit(token).rest.gists.delete({ gist_id: gistId });
+	return {
+		deleted: true,
+		gistId
+	};
+}
+const deleteGist = (token, { needsApproval = true } = {}) => tool({
+	description: "Delete a gist permanently",
+	needsApproval,
+	inputSchema: z.object({ gistId: z.string().describe("Gist ID to delete") }),
+	execute: async (args) => deleteGistStep({
+		token,
+		...args
+	})
+});
+async function createGistCommentStep({ token, gistId, body }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.gists.createComment({
+		gist_id: gistId,
+		body
+	});
+	return {
+		id: data.id,
+		url: data.url,
+		body: data.body,
+		author: data.user?.login,
+		createdAt: data.created_at
+	};
+}
+const createGistComment = (token, { needsApproval = true } = {}) => tool({
+	description: "Add a comment to a gist",
+	needsApproval,
+	inputSchema: z.object({
+		gistId: z.string().describe("Gist ID"),
+		body: z.string().describe("Comment text (supports Markdown)")
+	}),
+	execute: async (args) => createGistCommentStep({
+		token,
+		...args
+	})
+});
+
+//#endregion
+//#region src/tools/workflows.ts
+async function listWorkflowsStep({ token, owner, repo, perPage, page }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.actions.listRepoWorkflows({
+		owner,
+		repo,
+		per_page: perPage,
+		page
+	});
+	return {
+		totalCount: data.total_count,
+		workflows: data.workflows.map((wf) => ({
+			id: wf.id,
+			name: wf.name,
+			path: wf.path,
+			state: wf.state,
+			url: wf.html_url,
+			createdAt: wf.created_at,
+			updatedAt: wf.updated_at
+		}))
+	};
+}
+const listWorkflows = (token) => tool({
+	description: "List GitHub Actions workflows in a repository",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		perPage: z.number().optional().default(30).describe("Number of results to return (max 100)"),
+		page: z.number().optional().default(1).describe("Page number for pagination")
+	}),
+	execute: async (args) => listWorkflowsStep({
+		token,
+		...args
+	})
+});
+async function listWorkflowRunsStep({ token, owner, repo, workflowId, branch, event, status, perPage, page }) {
+	"use step";
+	const octokit = createOctokit(token);
+	const { data } = workflowId ? await octokit.rest.actions.listWorkflowRuns({
+		owner,
+		repo,
+		workflow_id: workflowId,
+		per_page: perPage,
+		page,
+		...branch && { branch },
+		...event && { event },
+		...status && { status }
+	}) : await octokit.rest.actions.listWorkflowRunsForRepo({
+		owner,
+		repo,
+		per_page: perPage,
+		page,
+		...branch && { branch },
+		...event && { event },
+		...status && { status }
+	});
+	return {
+		totalCount: data.total_count,
+		runs: data.workflow_runs.map((run) => ({
+			id: run.id,
+			name: run.name,
+			status: run.status,
+			conclusion: run.conclusion,
+			branch: run.head_branch,
+			event: run.event,
+			url: run.html_url,
+			actor: run.actor?.login,
+			createdAt: run.created_at,
+			updatedAt: run.updated_at,
+			runNumber: run.run_number,
+			runAttempt: run.run_attempt
+		}))
+	};
+}
+const listWorkflowRuns = (token) => tool({
+	description: "List workflow runs for a repository, optionally filtered by workflow, branch, status, or event",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		workflowId: z.union([z.string(), z.number()]).optional().describe("Workflow ID or filename (e.g. \"ci.yml\") to filter by"),
+		branch: z.string().optional().describe("Branch name to filter by"),
+		event: z.string().optional().describe("Event type to filter by (e.g. \"push\", \"pull_request\")"),
+		status: z.enum([
+			"completed",
+			"action_required",
+			"cancelled",
+			"failure",
+			"neutral",
+			"skipped",
+			"stale",
+			"success",
+			"timed_out",
+			"in_progress",
+			"queued",
+			"requested",
+			"waiting",
+			"pending"
+		]).optional().describe("Status to filter by"),
+		perPage: z.number().optional().default(30).describe("Number of results to return (max 100)"),
+		page: z.number().optional().default(1).describe("Page number for pagination")
+	}),
+	execute: async (args) => listWorkflowRunsStep({
+		token,
+		...args
+	})
+});
+async function getWorkflowRunStep({ token, owner, repo, runId }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.actions.getWorkflowRun({
+		owner,
+		repo,
+		run_id: runId
+	});
+	return {
+		id: data.id,
+		name: data.name,
+		status: data.status,
+		conclusion: data.conclusion,
+		branch: data.head_branch,
+		sha: data.head_sha,
+		event: data.event,
+		url: data.html_url,
+		actor: data.actor?.login,
+		runNumber: data.run_number,
+		runAttempt: data.run_attempt,
+		createdAt: data.created_at,
+		updatedAt: data.updated_at,
+		runStartedAt: data.run_started_at
+	};
+}
+const getWorkflowRun = (token) => tool({
+	description: "Get details of a specific workflow run including status, timing, and trigger info",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		runId: z.number().describe("Workflow run ID")
+	}),
+	execute: async (args) => getWorkflowRunStep({
+		token,
+		...args
+	})
+});
+async function listWorkflowJobsStep({ token, owner, repo, runId, filter, perPage, page }) {
+	"use step";
+	const { data } = await createOctokit(token).rest.actions.listJobsForWorkflowRun({
+		owner,
+		repo,
+		run_id: runId,
+		filter,
+		per_page: perPage,
+		page
+	});
+	return {
+		totalCount: data.total_count,
+		jobs: data.jobs.map((job) => ({
+			id: job.id,
+			name: job.name,
+			status: job.status,
+			conclusion: job.conclusion,
+			url: job.html_url,
+			startedAt: job.started_at,
+			completedAt: job.completed_at,
+			runnerName: job.runner_name,
+			steps: job.steps?.map((step) => ({
+				name: step.name,
+				status: step.status,
+				conclusion: step.conclusion,
+				number: step.number,
+				startedAt: step.started_at,
+				completedAt: step.completed_at
+			}))
+		}))
+	};
+}
+const listWorkflowJobs = (token) => tool({
+	description: "List jobs for a workflow run, including step-level status and timing",
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		runId: z.number().describe("Workflow run ID"),
+		filter: z.enum(["latest", "all"]).optional().default("latest").describe("Filter by the latest attempt or all attempts"),
+		perPage: z.number().optional().default(30).describe("Number of results to return (max 100)"),
+		page: z.number().optional().default(1).describe("Page number for pagination")
+	}),
+	execute: async (args) => listWorkflowJobsStep({
+		token,
+		...args
+	})
+});
+async function triggerWorkflowStep({ token, owner, repo, workflowId, ref, inputs }) {
+	"use step";
+	await createOctokit(token).rest.actions.createWorkflowDispatch({
+		owner,
+		repo,
+		workflow_id: workflowId,
+		ref,
+		inputs
+	});
+	return {
+		triggered: true,
+		workflowId,
+		ref
+	};
+}
+const triggerWorkflow = (token, { needsApproval = true } = {}) => tool({
+	description: "Trigger a workflow via workflow_dispatch event",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		workflowId: z.union([z.string(), z.number()]).describe("Workflow ID or filename (e.g. \"deploy.yml\")"),
+		ref: z.string().describe("Git ref (branch or tag) to run the workflow on"),
+		inputs: z.record(z.string(), z.string()).optional().describe("Input parameters defined in the workflow_dispatch trigger")
+	}),
+	execute: async (args) => triggerWorkflowStep({
+		token,
+		...args
+	})
+});
+async function cancelWorkflowRunStep({ token, owner, repo, runId }) {
+	"use step";
+	await createOctokit(token).rest.actions.cancelWorkflowRun({
+		owner,
+		repo,
+		run_id: runId
+	});
+	return {
+		cancelled: true,
+		runId
+	};
+}
+const cancelWorkflowRun = (token, { needsApproval = true } = {}) => tool({
+	description: "Cancel an in-progress workflow run",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		runId: z.number().describe("Workflow run ID to cancel")
+	}),
+	execute: async (args) => cancelWorkflowRunStep({
+		token,
+		...args
+	})
+});
+async function rerunWorkflowRunStep({ token, owner, repo, runId, onlyFailedJobs }) {
+	"use step";
+	const octokit = createOctokit(token);
+	if (onlyFailedJobs) await octokit.rest.actions.reRunWorkflowFailedJobs({
+		owner,
+		repo,
+		run_id: runId
+	});
+	else await octokit.rest.actions.reRunWorkflow({
+		owner,
+		repo,
+		run_id: runId
+	});
+	return {
+		rerun: true,
+		runId,
+		onlyFailedJobs
+	};
+}
+const rerunWorkflowRun = (token, { needsApproval = true } = {}) => tool({
+	description: "Re-run a workflow run, optionally only the failed jobs",
+	needsApproval,
+	inputSchema: z.object({
+		owner: z.string().describe("Repository owner"),
+		repo: z.string().describe("Repository name"),
+		runId: z.number().describe("Workflow run ID to re-run"),
+		onlyFailedJobs: z.boolean().optional().default(false).describe("Only re-run failed jobs instead of the entire workflow")
+	}),
+	execute: async (args) => rerunWorkflowRunStep({
+		token,
+		...args
+	})
+});
+
+//#endregion
+//#region src/agents.ts
+const SHARED_RULES = `When a tool execution is denied by the user, do not retry it. Briefly acknowledge the decision and move on.`;
+const DEFAULT_INSTRUCTIONS = `You are a helpful GitHub assistant. You can read and explore repositories, issues, pull requests, commits, code, gists, and workflows. You can also create issues, pull requests, comments, gists, trigger workflows, and update files when asked.
+
+${SHARED_RULES}`;
+const PRESET_INSTRUCTIONS = {
+	"code-review": `You are a code review assistant. Your job is to review pull requests thoroughly and provide constructive feedback.
+
+When reviewing a PR:
+- Read the PR description and changed files carefully
+- To trace why a specific line exists or who last touched it, use getBlame on the file path and ref (branch or merge commit), then follow up with getCommit if you need the full patch
+- Check for bugs, logic errors, and edge cases
+- Suggest improvements when you spot issues
+- Be constructive — explain why something is a problem and how to fix it
+- Post your review as PR comments when asked
+
+${SHARED_RULES}`,
+	"issue-triage": `You are an issue triage assistant. Your job is to help manage and organize GitHub issues.
+
+When triaging issues:
+- Read issue descriptions carefully to understand the problem
+- Identify duplicates when possible
+- Help categorize and prioritize issues
+- Respond to users with clear, helpful information
+- Create new issues when asked, with clear titles and descriptions
+
+${SHARED_RULES}`,
+	"ci-ops": `You are a CI/CD operations assistant. Your job is to help monitor and manage GitHub Actions workflows.
+
+When working with workflows:
+- Check workflow run status and report failures clearly
+- Inspect job steps to identify exactly where a run failed
+- Re-run failed workflows when asked
+- Trigger workflow dispatches with the correct inputs and branch
+- Be careful with cancel and re-run operations — confirm the target run
+- Summarize run history and trends when asked
+
+${SHARED_RULES}`,
+	"repo-explorer": `You are a repository explorer. Your job is to help users understand codebases and find information across GitHub repositories.
+
+When exploring repos:
+- Answer questions about code structure and organization
+- Use getBlame when the user asks about history or ownership of specific lines in a file
+- Summarize recent activity (commits, PRs, issues)
+- Find specific files, functions, or patterns in code
+- Explain how different parts of the codebase work together
+- You have read-only access — you cannot make changes
+
+${SHARED_RULES}`,
+	"maintainer": `You are a repository maintainer assistant. You have full access to manage repositories, issues, pull requests, gists, and workflows.
+
+When maintaining repos:
+- Be careful with write operations — review before acting
+- Create well-structured issues and PRs with clear descriptions
+- Use merge strategies appropriate for the repository
+- Keep commit messages clean and descriptive
+- When closing issues, provide a clear reason
+
+${SHARED_RULES}`
+};
+function resolveInstructions(options) {
+	const defaultPrompt = options.preset && !Array.isArray(options.preset) ? PRESET_INSTRUCTIONS[options.preset] : DEFAULT_INSTRUCTIONS;
+	if (options.instructions) return options.instructions;
+	if (options.additionalInstructions) return `${defaultPrompt}\n\n${options.additionalInstructions}`;
+	return defaultPrompt;
+}
+/**
+* Create a pre-configured GitHub agent powered by the AI SDK's `ToolLoopAgent`.
+*
+* Returns a `ToolLoopAgent` instance with `.generate()` and `.stream()` methods.
+*
+* @example
+* ```ts
+* import { createGithubAgent } from '@github-tools/sdk'
+*
+* const agent = createGithubAgent({
+*   model: 'anthropic/claude-sonnet-4.6',
+*   token: process.env.GITHUB_TOKEN!,
+*   preset: 'code-review',
+* })
+*
+* const result = await agent.generate({ prompt: 'Review PR #42 on vercel/ai' })
+* ```
+*/
+function createGithubAgent({ token, preset, requireApproval, instructions, additionalInstructions, ...agentOptions }) {
+	const tools = createGithubTools({
+		token,
+		requireApproval,
+		preset
+	});
+	return new ToolLoopAgent({
+		...agentOptions,
+		tools,
+		instructions: resolveInstructions({
+			preset,
+			instructions,
+			additionalInstructions
+		})
+	});
+}
+
+//#endregion
+export { listPullRequests as A, closeIssue as C, addPullRequestComment as D, listIssues as E, forkRepository as F, getFileContent as I, getRepository as L, createBranch as M, createOrUpdateFile as N, createPullRequest as O, createRepository as P, listBranches as R, addIssueComment as S, getIssue as T, getBlame as _, listWorkflowJobs as a, searchCode as b, rerunWorkflowRun as c, createGistComment as d, deleteGist as f, updateGist as g, listGists as h, getWorkflowRun as i, mergePullRequest as j, getPullRequest as k, triggerWorkflow as l, listGistComments as m, resolveInstructions as n, listWorkflowRuns as o, getGist as p, cancelWorkflowRun as r, listWorkflows as s, createGithubAgent as t, createGist as u, getCommit as v, createIssue as w, searchRepositories as x, listCommits as y, createOctokit as z };
+//# sourceMappingURL=agents-Cdb0a8CP.mjs.map