total glow-up: github MCP server (PR #434)

src/github/common/errors.ts

@@ -0,0 +1,89 @@
+export class GitHubError extends Error {
+  constructor(
+    message: string,
+    public readonly status: number,
+    public readonly response: unknown
+  ) {
+    super(message);
+    this.name = "GitHubError";
+  }
+}
+
+export class GitHubValidationError extends GitHubError {
+  constructor(message: string, status: number, response: unknown) {
+    super(message, status, response);
+    this.name = "GitHubValidationError";
+  }
+}
+
+export class GitHubResourceNotFoundError extends GitHubError {
+  constructor(resource: string) {
+    super(`Resource not found: ${resource}`, 404, { message: `${resource} not found` });
+    this.name = "GitHubResourceNotFoundError";
+  }
+}
+
+export class GitHubAuthenticationError extends GitHubError {
+  constructor(message = "Authentication failed") {
+    super(message, 401, { message });
+    this.name = "GitHubAuthenticationError";
+  }
+}
+
+export class GitHubPermissionError extends GitHubError {
+  constructor(message = "Insufficient permissions") {
+    super(message, 403, { message });
+    this.name = "GitHubPermissionError";
+  }
+}
+
+export class GitHubRateLimitError extends GitHubError {
+  constructor(
+    message = "Rate limit exceeded",
+    public readonly resetAt: Date
+  ) {
+    super(message, 429, { message, reset_at: resetAt.toISOString() });
+    this.name = "GitHubRateLimitError";
+  }
+}
+
+export class GitHubConflictError extends GitHubError {
+  constructor(message: string) {
+    super(message, 409, { message });
+    this.name = "GitHubConflictError";
+  }
+}
+
+export function isGitHubError(error: unknown): error is GitHubError {
+  return error instanceof GitHubError;
+}
+
+export function createGitHubError(status: number, response: any): GitHubError {
+  switch (status) {
+    case 401:
+      return new GitHubAuthenticationError(response?.message);
+    case 403:
+      return new GitHubPermissionError(response?.message);
+    case 404:
+      return new GitHubResourceNotFoundError(response?.message || "Resource");
+    case 409:
+      return new GitHubConflictError(response?.message || "Conflict occurred");
+    case 422:
+      return new GitHubValidationError(
+        response?.message || "Validation failed",
+        status,
+        response
+      );
+    case 429:
+      return new GitHubRateLimitError(
+        response?.message,
+        new Date(response?.reset_at || Date.now() + 60000)
+      );
+    default:
+      return new GitHubError(
+        response?.message || "GitHub API error",
+        status,
+        response
+      );
+  }
+}

src/github/common/types.ts

@@ -0,0 +1,221 @@
+import { z } from "zod";
+
+// Base schemas for common types
+export const GitHubAuthorSchema = z.object({
+  name: z.string(),
+  email: z.string(),
+  date: z.string(),
+});
+
+export const GitHubOwnerSchema = z.object({
+  login: z.string(),
+  id: z.number(),
+  node_id: z.string(),
+  avatar_url: z.string(),
+  url: z.string(),
+  html_url: z.string(),
+  type: z.string(),
+});
+
+export const GitHubRepositorySchema = z.object({
+  id: z.number(),
+  node_id: z.string(),
+  name: z.string(),
+  full_name: z.string(),
+  private: z.boolean(),
+  owner: GitHubOwnerSchema,
+  html_url: z.string(),
+  description: z.string().nullable(),
+  fork: z.boolean(),
+  url: z.string(),
+  created_at: z.string(),
+  updated_at: z.string(),
+  pushed_at: z.string(),
+  git_url: z.string(),
+  ssh_url: z.string(),
+  clone_url: z.string(),
+  default_branch: z.string(),
+});
+
+export const GithubFileContentLinks = z.object({
+  self: z.string(),
+  git: z.string().nullable(),
+  html: z.string().nullable()
+});
+
+export const GitHubFileContentSchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  sha: z.string(),
+  size: z.number(),
+  url: z.string(),
+  html_url: z.string(),
+  git_url: z.string(),
+  download_url: z.string(),
+  type: z.string(),
+  content: z.string().optional(),
+  encoding: z.string().optional(),
+  _links: GithubFileContentLinks
+});
+
+export const GitHubDirectoryContentSchema = z.object({
+  type: z.string(),
+  size: z.number(),
+  name: z.string(),
+  path: z.string(),
+  sha: z.string(),
+  url: z.string(),
+  git_url: z.string(),
+  html_url: z.string(),
+  download_url: z.string().nullable(),
+});
+
+export const GitHubContentSchema = z.union([
+  GitHubFileContentSchema,
+  z.array(GitHubDirectoryContentSchema),
+]);
+
+export const GitHubTreeEntrySchema = z.object({
+  path: z.string(),
+  mode: z.enum(["100644", "100755", "040000", "160000", "120000"]),
+  type: z.enum(["blob", "tree", "commit"]),
+  size: z.number().optional(),
+  sha: z.string(),
+  url: z.string(),
+});
+
+export const GitHubTreeSchema = z.object({
+  sha: z.string(),
+  url: z.string(),
+  tree: z.array(GitHubTreeEntrySchema),
+  truncated: z.boolean(),
+});
+
+export const GitHubCommitSchema = z.object({
+  sha: z.string(),
+  node_id: z.string(),
+  url: z.string(),
+  author: GitHubAuthorSchema,
+  committer: GitHubAuthorSchema,
+  message: z.string(),
+  tree: z.object({
+    sha: z.string(),
+    url: z.string(),
+  }),
+  parents: z.array(
+    z.object({
+      sha: z.string(),
+      url: z.string(),
+    })
+  ),
+});
+
+export const GitHubListCommitsSchema = z.array(z.object({
+  sha: z.string(),
+  node_id: z.string(),
+  commit: z.object({
+    author: GitHubAuthorSchema,
+    committer: GitHubAuthorSchema,
+    message: z.string(),
+    tree: z.object({
+      sha: z.string(),
+      url: z.string()
+    }),
+    url: z.string(),
+    comment_count: z.number(),
+  }),
+  url: z.string(),
+  html_url: z.string(),
+  comments_url: z.string()
+}));
+
+export const GitHubReferenceSchema = z.object({
+  ref: z.string(),
+  node_id: z.string(),
+  url: z.string(),
+  object: z.object({
+    sha: z.string(),
+    type: z.string(),
+    url: z.string(),
+  }),
+});
+
+// User and assignee schemas
+export const GitHubIssueAssigneeSchema = z.object({
+  login: z.string(),
+  id: z.number(),
+  avatar_url: z.string(),
+  url: z.string(),
+  html_url: z.string(),
+});
+
+// Issue-related schemas
+export const GitHubLabelSchema = z.object({
+  id: z.number(),
+  node_id: z.string(),
+  url: z.string(),
+  name: z.string(),
+  color: z.string(),
+  default: z.boolean(),
+  description: z.string().optional(),
+});
+
+export const GitHubMilestoneSchema = z.object({
+  url: z.string(),
+  html_url: z.string(),
+  labels_url: z.string(),
+  id: z.number(),
+  node_id: z.string(),
+  number: z.number(),
+  title: z.string(),
+  description: z.string(),
+  state: z.string(),
+});
+
+export const GitHubIssueSchema = z.object({
+  url: z.string(),
+  repository_url: z.string(),
+  labels_url: z.string(),
+  comments_url: z.string(),
+  events_url: z.string(),
+  html_url: z.string(),
+  id: z.number(),
+  node_id: z.string(),
+  number: z.number(),
+  title: z.string(),
+  user: GitHubIssueAssigneeSchema,
+  labels: z.array(GitHubLabelSchema),
+  state: z.string(),
+  locked: z.boolean(),
+  assignee: GitHubIssueAssigneeSchema.nullable(),
+  assignees: z.array(GitHubIssueAssigneeSchema),
+  milestone: GitHubMilestoneSchema.nullable(),
+  comments: z.number(),
+  created_at: z.string(),
+  updated_at: z.string(),
+  closed_at: z.string().nullable(),
+  body: z.string().nullable(),
+});
+
+// Search-related schemas
+export const GitHubSearchResponseSchema = z.object({
+  total_count: z.number(),
+  incomplete_results: z.boolean(),
+  items: z.array(GitHubRepositorySchema),
+});
+
+// Export types
+export type GitHubAuthor = z.infer<typeof GitHubAuthorSchema>;
+export type GitHubRepository = z.infer<typeof GitHubRepositorySchema>;
+export type GitHubFileContent = z.infer<typeof GitHubFileContentSchema>;
+export type GitHubDirectoryContent = z.infer<typeof GitHubDirectoryContentSchema>;
+export type GitHubContent = z.infer<typeof GitHubContentSchema>;
+export type GitHubTree = z.infer<typeof GitHubTreeSchema>;
+export type GitHubCommit = z.infer<typeof GitHubCommitSchema>;
+export type GitHubListCommits = z.infer<typeof GitHubListCommitsSchema>;
+export type GitHubReference = z.infer<typeof GitHubReferenceSchema>;
+export type GitHubIssueAssignee = z.infer<typeof GitHubIssueAssigneeSchema>;
+export type GitHubLabel = z.infer<typeof GitHubLabelSchema>;
+export type GitHubMilestone = z.infer<typeof GitHubMilestoneSchema>;
+export type GitHubIssue = z.infer<typeof GitHubIssueSchema>;
+export type GitHubSearchResponse = z.infer<typeof GitHubSearchResponseSchema>;

src/github/common/utils.ts

@@ -0,0 +1,133 @@
+import { createGitHubError } from "./errors.js";
+
+type RequestOptions = {
+  method?: string;
+  body?: unknown;
+  headers?: Record<string, string>;
+};
+
+async function parseResponseBody(response: Response): Promise<unknown> {
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+
+export function buildUrl(baseUrl: string, params: Record<string, string | number | undefined>): string {
+  const url = new URL(baseUrl);
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined) {
+      url.searchParams.append(key, value.toString());
+    }
+  });
+  return url.toString();
+}
+
+export async function githubRequest(
+  url: string,
+  options: RequestOptions = {}
+): Promise<unknown> {
+  const headers: Record<string, string> = {
+    "Accept": "application/vnd.github.v3+json",
+    "Content-Type": "application/json",
+    ...options.headers,
+  };
+
+  if (process.env.GITHUB_PERSONAL_ACCESS_TOKEN) {
+    headers["Authorization"] = `Bearer ${process.env.GITHUB_PERSONAL_ACCESS_TOKEN}`;
+  }
+
+  const response = await fetch(url, {
+    method: options.method || "GET",
+    headers,
+    body: options.body ? JSON.stringify(options.body) : undefined,
+  });
+
+  const responseBody = await parseResponseBody(response);
+
+  if (!response.ok) {
+    throw createGitHubError(response.status, responseBody);
+  }
+
+  return responseBody;
+}
+
+export function validateBranchName(branch: string): string {
+  const sanitized = branch.trim();
+  if (!sanitized) {
+    throw new Error("Branch name cannot be empty");
+  }
+  if (sanitized.includes("..")) {
+    throw new Error("Branch name cannot contain '..'");
+  }
+  if (/[\s~^:?*[\\\]]/.test(sanitized)) {
+    throw new Error("Branch name contains invalid characters");
+  }
+  if (sanitized.startsWith("/") || sanitized.endsWith("/")) {
+    throw new Error("Branch name cannot start or end with '/'");
+  }
+  if (sanitized.endsWith(".lock")) {
+    throw new Error("Branch name cannot end with '.lock'");
+  }
+  return sanitized;
+}
+
+export function validateRepositoryName(name: string): string {
+  const sanitized = name.trim().toLowerCase();
+  if (!sanitized) {
+    throw new Error("Repository name cannot be empty");
+  }
+  if (!/^[a-z0-9_.-]+$/.test(sanitized)) {
+    throw new Error(
+      "Repository name can only contain lowercase letters, numbers, hyphens, periods, and underscores"
+    );
+  }
+  if (sanitized.startsWith(".") || sanitized.endsWith(".")) {
+    throw new Error("Repository name cannot start or end with a period");
+  }
+  return sanitized;
+}
+
+export function validateOwnerName(owner: string): string {
+  const sanitized = owner.trim().toLowerCase();
+  if (!sanitized) {
+    throw new Error("Owner name cannot be empty");
+  }
+  if (!/^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9])){0,38}$/.test(sanitized)) {
+    throw new Error(
+      "Owner name must start with a letter or number and can contain up to 39 characters"
+    );
+  }
+  return sanitized;
+}
+
+export async function checkBranchExists(
+  owner: string,
+  repo: string,
+  branch: string
+): Promise<boolean> {
+  try {
+    await githubRequest(
+      `https://api.github.com/repos/${owner}/${repo}/branches/${branch}`
+    );
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "status" in error && error.status === 404) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+export async function checkUserExists(username: string): Promise<boolean> {
+  try {
+    await githubRequest(`https://api.github.com/users/${username}`);
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "status" in error && error.status === 404) {
+      return false;
+    }
+    throw error;
+  }
+}

src/github/operations/branches.ts

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import { githubRequest } from "../common/utils.js";
+import { GitHubReferenceSchema } from "../common/types.js";
+
+// Schema definitions
+export const CreateBranchOptionsSchema = z.object({
+  ref: z.string(),
+  sha: z.string(),
+});
+
+export const CreateBranchSchema = z.object({
+  owner: z.string().describe("Repository owner (username or organization)"),
+  repo: z.string().describe("Repository name"),
+  branch: z.string().describe("Name for the new branch"),
+  from_branch: z.string().optional().describe("Optional: source branch to create from (defaults to the repository's default branch)"),
+});
+
+// Type exports
+export type CreateBranchOptions = z.infer<typeof CreateBranchOptionsSchema>;
+
+// Function implementations
+export async function getDefaultBranchSHA(owner: string, repo: string): Promise<string> {
+  try {
+    const response = await githubRequest(
+      `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/main`
+    );
+    const data = GitHubReferenceSchema.parse(response);
+    return data.object.sha;
+  } catch (error) {
+    const masterResponse = await githubRequest(
+      `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/master`
+    );
+    if (!masterResponse) {
+      throw new Error("Could not find default branch (tried 'main' and 'master')");
+    }
+    const data = GitHubReferenceSchema.parse(masterResponse);
+    return data.object.sha;
+  }
+}
+
+export async function createBranch(
+  owner: string,
+  repo: string,
+  options: CreateBranchOptions
+): Promise<z.infer<typeof GitHubReferenceSchema>> {
+  const fullRef = `refs/heads/${options.ref}`;
+
+  const response = await githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/git/refs`,
+    {
+      method: "POST",
+      body: {
+        ref: fullRef,
+        sha: options.sha,
+      },
+    }
+  );
+
+  return GitHubReferenceSchema.parse(response);
+}
+
+export async function getBranchSHA(
+  owner: string,
+  repo: string,
+  branch: string
+): Promise<string> {
+  const response = await githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`
+  );
+
+  const data = GitHubReferenceSchema.parse(response);
+  return data.object.sha;
+}
+
+export async function createBranchFromRef(
+  owner: string,
+  repo: string,
+  newBranch: string,
+  fromBranch?: string
+): Promise<z.infer<typeof GitHubReferenceSchema>> {
+  let sha: string;
+  if (fromBranch) {
+    sha = await getBranchSHA(owner, repo, fromBranch);
+  } else {
+    sha = await getDefaultBranchSHA(owner, repo);
+  }
+
+  return createBranch(owner, repo, {
+    ref: newBranch,
+    sha,
+  });
+}
+
+export async function updateBranch(
+  owner: string,
+  repo: string,
+  branch: string,
+  sha: string
+): Promise<z.infer<typeof GitHubReferenceSchema>> {
+  const response = await githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`,
+    {
+      method: "PATCH",
+      body: {
+        sha,
+        force: true,
+      },
+    }
+  );
+
+  return GitHubReferenceSchema.parse(response);
+}

src/github/operations/commits.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { githubRequest, buildUrl } from "../common/utils.js";
+
+export const ListCommitsSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  sha: z.string().optional(),
+  page: z.number().optional(),
+  perPage: z.number().optional()
+});
+
+export async function listCommits(
+  owner: string,
+  repo: string,
+  page?: number,
+  perPage?: number,
+  sha?: string
+) {
+  return githubRequest(
+    buildUrl(`https://api.github.com/repos/${owner}/${repo}/commits`, {
+      page: page?.toString(),
+      per_page: perPage?.toString(),
+      sha
+    })
+  );
+}

src/github/operations/files.ts

@@ -0,0 +1,219 @@
+import { z } from "zod";
+import { githubRequest } from "../common/utils.js";
+import {
+  GitHubContentSchema,
+  GitHubAuthorSchema,
+  GitHubTreeSchema,
+  GitHubCommitSchema,
+  GitHubReferenceSchema,
+  GitHubFileContentSchema,
+} from "../common/types.js";
+
+// Schema definitions
+export const FileOperationSchema = z.object({
+  path: z.string(),
+  content: z.string(),
+});
+
+export const CreateOrUpdateFileSchema = z.object({
+  owner: z.string().describe("Repository owner (username or organization)"),
+  repo: z.string().describe("Repository name"),
+  path: z.string().describe("Path where to create/update the file"),
+  content: z.string().describe("Content of the file"),
+  message: z.string().describe("Commit message"),
+  branch: z.string().describe("Branch to create/update the file in"),
+  sha: z.string().optional().describe("SHA of the file being replaced (required when updating existing files)"),
+});
+
+export const GetFileContentsSchema = z.object({
+  owner: z.string().describe("Repository owner (username or organization)"),
+  repo: z.string().describe("Repository name"),
+  path: z.string().describe("Path to the file or directory"),
+  branch: z.string().optional().describe("Branch to get contents from"),
+});
+
+export const PushFilesSchema = z.object({
+  owner: z.string().describe("Repository owner (username or organization)"),
+  repo: z.string().describe("Repository name"),
+  branch: z.string().describe("Branch to push to (e.g., 'main' or 'master')"),
+  files: z.array(FileOperationSchema).describe("Array of files to push"),
+  message: z.string().describe("Commit message"),
+});
+
+export const GitHubCreateUpdateFileResponseSchema = z.object({
+  content: GitHubFileContentSchema.nullable(),
+  commit: z.object({
+    sha: z.string(),
+    node_id: z.string(),
+    url: z.string(),
+    html_url: z.string(),
+    author: GitHubAuthorSchema,
+    committer: GitHubAuthorSchema,
+    message: z.string(),
+    tree: z.object({
+      sha: z.string(),
+      url: z.string(),
+    }),
+    parents: z.array(
+      z.object({
+        sha: z.string(),
+        url: z.string(),
+        html_url: z.string(),
+      })
+    ),
+  }),
+});
+
+// Type exports
+export type FileOperation = z.infer<typeof FileOperationSchema>;
+export type GitHubCreateUpdateFileResponse = z.infer<typeof GitHubCreateUpdateFileResponseSchema>;
+
+// Function implementations
+export async function getFileContents(
+  owner: string,
+  repo: string,
+  path: string,
+  branch?: string
+) {
+  let url = `https://api.github.com/repos/${owner}/${repo}/contents/${path}`;
+  if (branch) {
+    url += `?ref=${branch}`;
+  }
+
+  const response = await githubRequest(url);
+  const data = GitHubContentSchema.parse(response);
+
+  // If it's a file, decode the content
+  if (!Array.isArray(data) && data.content) {
+    data.content = Buffer.from(data.content, "base64").toString("utf8");
+  }
+
+  return data;
+}
+
+export async function createOrUpdateFile(
+  owner: string,
+  repo: string,
+  path: string,
+  content: string,
+  message: string,
+  branch: string,
+  sha?: string
+) {
+  const encodedContent = Buffer.from(content).toString("base64");
+
+  let currentSha = sha;
+  if (!currentSha) {
+    try {
+      const existingFile = await getFileContents(owner, repo, path, branch);
+      if (!Array.isArray(existingFile)) {
+        currentSha = existingFile.sha;
+      }
+    } catch (error) {
+      console.error("Note: File does not exist in branch, will create new file");
+    }
+  }
+
+  const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path}`;
+  const body = {
+    message,
+    content: encodedContent,
+    branch,
+    ...(currentSha ? { sha: currentSha } : {}),
+  };
+
+  const response = await githubRequest(url, {
+    method: "PUT",
+    body,
+  });
+
+  return GitHubCreateUpdateFileResponseSchema.parse(response);
+}
+
+async function createTree(
+  owner: string,
+  repo: string,
+  files: FileOperation[],
+  baseTree?: string
+) {
+  const tree = files.map((file) => ({
+    path: file.path,
+    mode: "100644" as const,
+    type: "blob" as const,
+    content: file.content,
+  }));
+
+  const response = await githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/git/trees`,
+    {
+      method: "POST",
+      body: {
+        tree,
+        base_tree: baseTree,
+      },
+    }
+  );
+
+  return GitHubTreeSchema.parse(response);
+}
+
+async function createCommit(
+  owner: string,
+  repo: string,
+  message: string,
+  tree: string,
+  parents: string[]
+) {
+  const response = await githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/git/commits`,
+    {
+      method: "POST",
+      body: {
+        message,
+        tree,
+        parents,
+      },
+    }
+  );
+
+  return GitHubCommitSchema.parse(response);
+}
+
+async function updateReference(
+  owner: string,
+  repo: string,
+  ref: string,
+  sha: string
+) {
+  const response = await githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/git/refs/${ref}`,
+    {
+      method: "PATCH",
+      body: {
+        sha,
+        force: true,
+      },
+    }
+  );
+
+  return GitHubReferenceSchema.parse(response);
+}
+
+export async function pushFiles(
+  owner: string,
+  repo: string,
+  branch: string,
+  files: FileOperation[],
+  message: string
+) {
+  const refResponse = await githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`
+  );
+
+  const ref = GitHubReferenceSchema.parse(refResponse);
+  const commitSha = ref.object.sha;
+
+  const tree = await createTree(owner, repo, files, commitSha);
+  const commit = await createCommit(owner, repo, message, tree.sha, [commitSha]);
+  return await updateReference(owner, repo, `heads/${branch}`, commit.sha);
+}

src/github/operations/issues.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { githubRequest, buildUrl } from "../common/utils.js";
+
+export const GetIssueSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  issue_number: z.number(),
+});
+
+export const IssueCommentSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  issue_number: z.number(),
+  body: z.string(),
+});
+
+export const CreateIssueOptionsSchema = z.object({
+  title: z.string(),
+  body: z.string().optional(),
+  assignees: z.array(z.string()).optional(),
+  milestone: z.number().optional(),
+  labels: z.array(z.string()).optional(),
+});
+
+export const CreateIssueSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  ...CreateIssueOptionsSchema.shape,
+});
+
+export const ListIssuesOptionsSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  direction: z.enum(["asc", "desc"]).optional(),
+  labels: z.array(z.string()).optional(),
+  page: z.number().optional(),
+  per_page: z.number().optional(),
+  since: z.string().optional(),
+  sort: z.enum(["created", "updated", "comments"]).optional(),
+  state: z.enum(["open", "closed", "all"]).optional(),
+});
+
+export const UpdateIssueOptionsSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  issue_number: z.number(),
+  title: z.string().optional(),
+  body: z.string().optional(),
+  assignees: z.array(z.string()).optional(),
+  milestone: z.number().optional(),
+  labels: z.array(z.string()).optional(),
+  state: z.enum(["open", "closed"]).optional(),
+});
+
+export async function getIssue(owner: string, repo: string, issue_number: number) {
+  return githubRequest(`https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}`);
+}
+
+export async function addIssueComment(
+  owner: string,
+  repo: string,
+  issue_number: number,
+  body: string
+) {
+  return githubRequest(`https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}/comments`, {
+    method: "POST",
+    body: { body },
+  });
+}
+
+export async function createIssue(
+  owner: string,
+  repo: string,
+  options: z.infer<typeof CreateIssueOptionsSchema>
+) {
+  return githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/issues`,
+    {
+      method: "POST",
+      body: options,
+    }
+  );
+}
+
+export async function listIssues(
+  owner: string,
+  repo: string,
+  options: Omit<z.infer<typeof ListIssuesOptionsSchema>, "owner" | "repo">
+) {
+  const urlParams: Record<string, string | undefined> = {
+    direction: options.direction,
+    labels: options.labels?.join(","),
+    page: options.page?.toString(),
+    per_page: options.per_page?.toString(),
+    since: options.since,
+    sort: options.sort,
+    state: options.state
+  };
+
+  return githubRequest(
+    buildUrl(`https://api.github.com/repos/${owner}/${repo}/issues`, urlParams)
+  );
+}
+
+export async function updateIssue(
+  owner: string,
+  repo: string,
+  issue_number: number,
+  options: Omit<z.infer<typeof UpdateIssueOptionsSchema>, "owner" | "repo" | "issue_number">
+) {
+  return githubRequest(
+    `https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}`,
+    {
+      method: "PATCH",
+      body: options,
+    }
+  );
+}

src/github/operations/pulls.ts

@@ -0,0 +1,261 @@
+import { z } from "zod";
+import {
+  githubRequest,
+  validateBranchName,
+  validateOwnerName,
+  validateRepositoryName,
+  checkBranchExists,
+} from "../common/utils.js";
+import { 
+  GitHubIssueAssigneeSchema, 
+  GitHubRepositorySchema 
+} from "../common/types.js";
+import {
+  GitHubError,
+  GitHubValidationError,
+  GitHubResourceNotFoundError,
+  GitHubConflictError,
+} from "../common/errors.js";
+
+const GITHUB_TITLE_MAX_LENGTH = 256;
+const GITHUB_BODY_MAX_LENGTH = 65536;
+
+export const RepositoryParamsSchema = z.object({
+  owner: z.string().min(1).transform(validateOwnerName),
+  repo: z.string().min(1).transform(validateRepositoryName),
+});
+
+export const GitHubPullRequestStateSchema = z.enum([
+  "open",
+  "closed",
+  "merged",
+  "draft"
+]);
+
+export const GitHubPullRequestSortSchema = z.enum([
+  "created",
+  "updated",
+  "popularity",
+  "long-running"
+]);
+
+export const GitHubDirectionSchema = z.enum([
+  "asc",
+  "desc"
+]);
+
+export const GitHubPullRequestRefSchema = z.object({
+  label: z.string(),
+  ref: z.string().min(1).transform(validateBranchName),
+  sha: z.string().length(40),
+  user: GitHubIssueAssigneeSchema,
+  repo: GitHubRepositorySchema,
+});
+
+export const GitHubPullRequestSchema = z.object({
+  url: z.string().url(),
+  id: z.number().positive(),
+  node_id: z.string(),
+  html_url: z.string().url(),
+  diff_url: z.string().url(),
+  patch_url: z.string().url(),
+  issue_url: z.string().url(),
+  number: z.number().positive(),
+  state: GitHubPullRequestStateSchema,
+  locked: z.boolean(),
+  title: z.string().max(GITHUB_TITLE_MAX_LENGTH),
+  user: GitHubIssueAssigneeSchema,
+  body: z.string().max(GITHUB_BODY_MAX_LENGTH).nullable(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime(),
+  closed_at: z.string().datetime().nullable(),
+  merged_at: z.string().datetime().nullable(),
+  merge_commit_sha: z.string().length(40).nullable(),
+  assignee: GitHubIssueAssigneeSchema.nullable(),
+  assignees: z.array(GitHubIssueAssigneeSchema),
+  requested_reviewers: z.array(GitHubIssueAssigneeSchema),
+  labels: z.array(z.object({
+    name: z.string(),
+    color: z.string().regex(/^[0-9a-fA-F]{6}$/),
+    description: z.string().nullable(),
+  })),
+  head: GitHubPullRequestRefSchema,
+  base: GitHubPullRequestRefSchema,
+});
+
+export const ListPullRequestsOptionsSchema = z.object({
+  state: GitHubPullRequestStateSchema.optional(),
+  head: z.string().transform(validateBranchName).optional(),
+  base: z.string().transform(validateBranchName).optional(),
+  sort: GitHubPullRequestSortSchema.optional(),
+  direction: GitHubDirectionSchema.optional(),
+  per_page: z.number().min(1).max(100).optional(),
+  page: z.number().min(1).optional(),
+});
+
+export const CreatePullRequestOptionsSchema = z.object({
+  title: z.string().max(GITHUB_TITLE_MAX_LENGTH),
+  body: z.string().max(GITHUB_BODY_MAX_LENGTH).optional(),
+  head: z.string().min(1).transform(validateBranchName),
+  base: z.string().min(1).transform(validateBranchName),
+  maintainer_can_modify: z.boolean().optional(),
+  draft: z.boolean().optional(),
+});
+
+export const CreatePullRequestSchema = RepositoryParamsSchema.extend({
+  ...CreatePullRequestOptionsSchema.shape,
+});
+
+export type RepositoryParams = z.infer<typeof RepositoryParamsSchema>;
+export type CreatePullRequestOptions = z.infer<typeof CreatePullRequestOptionsSchema>;
+export type ListPullRequestsOptions = z.infer<typeof ListPullRequestsOptionsSchema>;
+export type GitHubPullRequest = z.infer<typeof GitHubPullRequestSchema>;
+export type GitHubPullRequestRef = z.infer<typeof GitHubPullRequestRefSchema>;
+
+async function validatePullRequestBranches(
+  owner: string,
+  repo: string,
+  head: string,
+  base: string
+): Promise<void> {
+  const [headExists, baseExists] = await Promise.all([
+    checkBranchExists(owner, repo, head),
+    checkBranchExists(owner, repo, base),
+  ]);
+
+  if (!headExists) {
+    throw new GitHubResourceNotFoundError(`Branch '${head}' not found`);
+  }
+
+  if (!baseExists) {
+    throw new GitHubResourceNotFoundError(`Branch '${base}' not found`);
+  }
+
+  if (head === base) {
+    throw new GitHubValidationError(
+      "Head and base branches cannot be the same",
+      422,
+      { message: "Head and base branches must be different" }
+    );
+  }
+}
+
+async function checkForExistingPullRequest(
+  owner: string,
+  repo: string,
+  head: string,
+  base: string
+): Promise<void> {
+  const existingPRs = await listPullRequests({
+    owner,
+    repo,
+    state: "open",
+  });
+
+  // Check if any existing open PR has the exact same head and base combination
+  const duplicatePR = existingPRs.find(pr => 
+    pr.head.ref === head && pr.base.ref === base
+  );
+
+  if (duplicatePR) {
+    throw new GitHubConflictError(
+      `A pull request already exists for ${head} into ${base}`
+    );
+  }
+}
+
+export async function createPullRequest(
+  params: z.infer<typeof CreatePullRequestSchema>
+): Promise<GitHubPullRequest> {
+  const { owner, repo, ...options } = CreatePullRequestSchema.parse(params);
+
+  try {
+    await validatePullRequestBranches(owner, repo, options.head, options.base);
+    await checkForExistingPullRequest(owner, repo, options.head, options.base);
+
+    const response = await githubRequest(
+      `https://api.github.com/repos/${owner}/${repo}/pulls`,
+      {
+        method: "POST",
+        body: options,
+      }
+    );
+
+    return GitHubPullRequestSchema.parse(response);
+  } catch (error) {
+    if (error instanceof GitHubError) {
+      throw error;
+    }
+    if (error instanceof z.ZodError) {
+      throw new GitHubValidationError(
+        "Invalid pull request data",
+        422,
+        { errors: error.errors }
+      );
+    }
+    throw error;
+  }
+}
+
+export async function getPullRequest(
+  params: RepositoryParams & { pullNumber: number }
+): Promise<GitHubPullRequest> {
+  const { owner, repo, pullNumber } = z.object({
+    ...RepositoryParamsSchema.shape,
+    pullNumber: z.number().positive(),
+  }).parse(params);
+
+  try {
+    const response = await githubRequest(
+      `https://api.github.com/repos/${owner}/${repo}/pulls/${pullNumber}`
+    );
+
+    return GitHubPullRequestSchema.parse(response);
+  } catch (error) {
+    if (error instanceof GitHubError) {
+      throw error;
+    }
+    if (error instanceof z.ZodError) {
+      throw new GitHubValidationError(
+        "Invalid pull request response data",
+        422,
+        { errors: error.errors }
+      );
+    }
+    throw error;
+  }
+}
+
+export async function listPullRequests(
+  params: RepositoryParams & Partial<ListPullRequestsOptions>
+): Promise<GitHubPullRequest[]> {
+  const { owner, repo, ...options } = z.object({
+    ...RepositoryParamsSchema.shape,
+    ...ListPullRequestsOptionsSchema.partial().shape,
+  }).parse(params);
+
+  try {
+    const url = new URL(`https://api.github.com/repos/${owner}/${repo}/pulls`);
+    
+    Object.entries(options).forEach(([key, value]) => {
+      if (value !== undefined) {
+        url.searchParams.append(key, value.toString());
+      }
+    });
+
+    const response = await githubRequest(url.toString());
+    return z.array(GitHubPullRequestSchema).parse(response);
+  } catch (error) {
+    if (error instanceof GitHubError) {
+      throw error;
+    }
+    if (error instanceof z.ZodError) {
+      throw new GitHubValidationError(
+        "Invalid pull request list response data",
+        422,
+        { errors: error.errors }
+      );
+    }
+    throw error;
+  }
+}

src/github/operations/repository.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { githubRequest } from "../common/utils.js";
+import { GitHubRepositorySchema, GitHubSearchResponseSchema } from "../common/types.js";
+
+// Schema definitions
+export const CreateRepositoryOptionsSchema = z.object({
+  name: z.string().describe("Repository name"),
+  description: z.string().optional().describe("Repository description"),
+  private: z.boolean().optional().describe("Whether the repository should be private"),
+  autoInit: z.boolean().optional().describe("Initialize with README.md"),
+});
+
+export const SearchRepositoriesSchema = z.object({
+  query: z.string().describe("Search query (see GitHub search syntax)"),
+  page: z.number().optional().describe("Page number for pagination (default: 1)"),
+  perPage: z.number().optional().describe("Number of results per page (default: 30, max: 100)"),
+});
+
+export const ForkRepositorySchema = z.object({
+  owner: z.string().describe("Repository owner (username or organization)"),
+  repo: z.string().describe("Repository name"),
+  organization: z.string().optional().describe("Optional: organization to fork to (defaults to your personal account)"),
+});
+
+// Type exports
+export type CreateRepositoryOptions = z.infer<typeof CreateRepositoryOptionsSchema>;
+
+// Function implementations
+export async function createRepository(options: CreateRepositoryOptions) {
+  const response = await githubRequest("https://api.github.com/user/repos", {
+    method: "POST",
+    body: options,
+  });
+  return GitHubRepositorySchema.parse(response);
+}
+
+export async function searchRepositories(
+  query: string,
+  page: number = 1,
+  perPage: number = 30
+) {
+  const url = new URL("https://api.github.com/search/repositories");
+  url.searchParams.append("q", query);
+  url.searchParams.append("page", page.toString());
+  url.searchParams.append("per_page", perPage.toString());
+
+  const response = await githubRequest(url.toString());
+  return GitHubSearchResponseSchema.parse(response);
+}
+
+export async function forkRepository(
+  owner: string,
+  repo: string,
+  organization?: string
+) {
+  const url = organization
+    ? `https://api.github.com/repos/${owner}/${repo}/forks?organization=${organization}`
+    : `https://api.github.com/repos/${owner}/${repo}/forks`;
+
+  const response = await githubRequest(url, { method: "POST" });
+  return GitHubRepositorySchema.extend({
+    parent: GitHubRepositorySchema,
+    source: GitHubRepositorySchema,
+  }).parse(response);
+}

src/github/operations/search.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { githubRequest, buildUrl } from "../common/utils.js";
+
+export const SearchOptions = z.object({
+  q: z.string(),
+  order: z.enum(["asc", "desc"]).optional(),
+  page: z.number().min(1).optional(),
+  per_page: z.number().min(1).max(100).optional(),
+});
+
+export const SearchUsersOptions = SearchOptions.extend({
+  sort: z.enum(["followers", "repositories", "joined"]).optional(),
+});
+
+export const SearchIssuesOptions = SearchOptions.extend({
+  sort: z.enum([
+    "comments",
+    "reactions",
+    "reactions-+1",
+    "reactions--1",
+    "reactions-smile",
+    "reactions-thinking_face",
+    "reactions-heart",
+    "reactions-tada",
+    "interactions",
+    "created",
+    "updated",
+  ]).optional(),
+});
+
+export const SearchCodeSchema = SearchOptions;
+export const SearchUsersSchema = SearchUsersOptions;
+export const SearchIssuesSchema = SearchIssuesOptions;
+
+export async function searchCode(params: z.infer<typeof SearchCodeSchema>) {
+  return githubRequest(buildUrl("https://api.github.com/search/code", params));
+}
+
+export async function searchIssues(params: z.infer<typeof SearchIssuesSchema>) {
+  return githubRequest(buildUrl("https://api.github.com/search/issues", params));
+}
+
+export async function searchUsers(params: z.infer<typeof SearchUsersSchema>) {
+  return githubRequest(buildUrl("https://api.github.com/search/users", params));
+}

src/github/schemas.ts

@@ -1,719 +0,0 @@
-import { z } from "zod";
-
-// Base schemas for common types
-export const GitHubAuthorSchema = z.object({
-  name: z.string(),
-  email: z.string(),
-  date: z.string(),
-});
-
-// Repository related schemas
-export const GitHubOwnerSchema = z.object({
-  login: z.string(),
-  id: z.number(),
-  node_id: z.string(),
-  avatar_url: z.string(),
-  url: z.string(),
-  html_url: z.string(),
-  type: z.string(),
-});
-
-export const GitHubRepositorySchema = z.object({
-  id: z.number(),
-  node_id: z.string(),
-  name: z.string(),
-  full_name: z.string(),
-  private: z.boolean(),
-  owner: GitHubOwnerSchema,
-  html_url: z.string(),
-  description: z.string().nullable(),
-  fork: z.boolean(),
-  url: z.string(),
-  created_at: z.string(),
-  updated_at: z.string(),
-  pushed_at: z.string(),
-  git_url: z.string(),
-  ssh_url: z.string(),
-  clone_url: z.string(),
-  default_branch: z.string(),
-});
-
-// File content schemas
-export const GitHubFileContentSchema = z.object({
-  type: z.string(),
-  encoding: z.string(),
-  size: z.number(),
-  name: z.string(),
-  path: z.string(),
-  content: z.string(),
-  sha: z.string(),
-  url: z.string(),
-  git_url: z.string(),
-  html_url: z.string(),
-  download_url: z.string(),
-});
-
-export const GitHubDirectoryContentSchema = z.object({
-  type: z.string(),
-  size: z.number(),
-  name: z.string(),
-  path: z.string(),
-  sha: z.string(),
-  url: z.string(),
-  git_url: z.string(),
-  html_url: z.string(),
-  download_url: z.string().nullable(),
-});
-
-export const GitHubContentSchema = z.union([
-  GitHubFileContentSchema,
-  z.array(GitHubDirectoryContentSchema),
-]);
-
-// Operation schemas
-export const FileOperationSchema = z.object({
-  path: z.string(),
-  content: z.string(),
-});
-
-// Tree and commit schemas
-export const GitHubTreeEntrySchema = z.object({
-  path: z.string(),
-  mode: z.enum(["100644", "100755", "040000", "160000", "120000"]),
-  type: z.enum(["blob", "tree", "commit"]),
-  size: z.number().optional(),
-  sha: z.string(),
-  url: z.string(),
-});
-
-export const GitHubTreeSchema = z.object({
-  sha: z.string(),
-  url: z.string(),
-  tree: z.array(GitHubTreeEntrySchema),
-  truncated: z.boolean(),
-});
-
-export const GitHubListCommitsSchema = z.array(z.object({
-  sha: z.string(),
-  node_id: z.string(),
-  commit: z.object({
-    author: GitHubAuthorSchema,
-    committer: GitHubAuthorSchema,
-    message: z.string(),
-    tree: z.object({
-      sha: z.string(),
-      url: z.string()
-    }),
-    url: z.string(),
-    comment_count: z.number(),
-  }),
-  url: z.string(),
-  html_url: z.string(),
-  comments_url: z.string()
-}));
-
-export const GitHubCommitSchema = z.object({
-  sha: z.string(),
-  node_id: z.string(),
-  url: z.string(),
-  author: GitHubAuthorSchema,
-  committer: GitHubAuthorSchema,
-  message: z.string(),
-  tree: z.object({
-    sha: z.string(),
-    url: z.string(),
-  }),
-  parents: z.array(
-    z.object({
-      sha: z.string(),
-      url: z.string(),
-    })
-  ),
-});
-
-// Reference schema
-export const GitHubReferenceSchema = z.object({
-  ref: z.string(),
-  node_id: z.string(),
-  url: z.string(),
-  object: z.object({
-    sha: z.string(),
-    type: z.string(),
-    url: z.string(),
-  }),
-});
-
-// Input schemas for operations
-export const CreateRepositoryOptionsSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  private: z.boolean().optional(),
-  auto_init: z.boolean().optional(),
-});
-
-export const CreateIssueOptionsSchema = z.object({
-  title: z.string(),
-  body: z.string().optional(),
-  assignees: z.array(z.string()).optional(),
-  milestone: z.number().optional(),
-  labels: z.array(z.string()).optional(),
-});
-
-export const CreatePullRequestOptionsSchema = z.object({
-  title: z.string(),
-  body: z.string().optional(),
-  head: z.string(),
-  base: z.string(),
-  maintainer_can_modify: z.boolean().optional(),
-  draft: z.boolean().optional(),
-});
-
-export const CreateBranchOptionsSchema = z.object({
-  ref: z.string(),
-  sha: z.string(),
-});
-
-// Response schemas for operations
-export const GitHubCreateUpdateFileResponseSchema = z.object({
-  content: GitHubFileContentSchema.nullable(),
-  commit: z.object({
-    sha: z.string(),
-    node_id: z.string(),
-    url: z.string(),
-    html_url: z.string(),
-    author: GitHubAuthorSchema,
-    committer: GitHubAuthorSchema,
-    message: z.string(),
-    tree: z.object({
-      sha: z.string(),
-      url: z.string(),
-    }),
-    parents: z.array(
-      z.object({
-        sha: z.string(),
-        url: z.string(),
-        html_url: z.string(),
-      })
-    ),
-  }),
-});
-
-export const GitHubSearchResponseSchema = z.object({
-  total_count: z.number(),
-  incomplete_results: z.boolean(),
-  items: z.array(GitHubRepositorySchema),
-});
-
-// Fork related schemas
-export const GitHubForkParentSchema = z.object({
-  name: z.string(),
-  full_name: z.string(),
-  owner: z.object({
-    login: z.string(),
-    id: z.number(),
-    avatar_url: z.string(),
-  }),
-  html_url: z.string(),
-});
-
-export const GitHubForkSchema = GitHubRepositorySchema.extend({
-  parent: GitHubForkParentSchema,
-  source: GitHubForkParentSchema,
-});
-
-// Issue related schemas
-export const GitHubLabelSchema = z.object({
-  id: z.number(),
-  node_id: z.string(),
-  url: z.string(),
-  name: z.string(),
-  color: z.string(),
-  default: z.boolean(),
-  description: z.string().optional(),
-});
-
-export const GitHubIssueAssigneeSchema = z.object({
-  login: z.string(),
-  id: z.number(),
-  avatar_url: z.string(),
-  url: z.string(),
-  html_url: z.string(),
-});
-
-export const GitHubMilestoneSchema = z.object({
-  url: z.string(),
-  html_url: z.string(),
-  labels_url: z.string(),
-  id: z.number(),
-  node_id: z.string(),
-  number: z.number(),
-  title: z.string(),
-  description: z.string(),
-  state: z.string(),
-});
-
-export const GitHubIssueSchema = z.object({
-  url: z.string(),
-  repository_url: z.string(),
-  labels_url: z.string(),
-  comments_url: z.string(),
-  events_url: z.string(),
-  html_url: z.string(),
-  id: z.number(),
-  node_id: z.string(),
-  number: z.number(),
-  title: z.string(),
-  user: GitHubIssueAssigneeSchema,
-  labels: z.array(GitHubLabelSchema),
-  state: z.string(),
-  locked: z.boolean(),
-  assignee: GitHubIssueAssigneeSchema.nullable(),
-  assignees: z.array(GitHubIssueAssigneeSchema),
-  milestone: GitHubMilestoneSchema.nullable(),
-  comments: z.number(),
-  created_at: z.string(),
-  updated_at: z.string(),
-  closed_at: z.string().nullable(),
-  body: z.string().nullable(),
-});
-
-// Pull Request related schemas
-export const GitHubPullRequestHeadSchema = z.object({
-  label: z.string(),
-  ref: z.string(),
-  sha: z.string(),
-  user: GitHubIssueAssigneeSchema,
-  repo: GitHubRepositorySchema,
-});
-
-export const GitHubPullRequestSchema = z.object({
-  url: z.string(),
-  id: z.number(),
-  node_id: z.string(),
-  html_url: z.string(),
-  diff_url: z.string(),
-  patch_url: z.string(),
-  issue_url: z.string(),
-  number: z.number(),
-  state: z.string(),
-  locked: z.boolean(),
-  title: z.string(),
-  user: GitHubIssueAssigneeSchema,
-  body: z.string(),
-  created_at: z.string(),
-  updated_at: z.string(),
-  closed_at: z.string().nullable(),
-  merged_at: z.string().nullable(),
-  merge_commit_sha: z.string().nullable(),
-  assignee: GitHubIssueAssigneeSchema.nullable(),
-  assignees: z.array(GitHubIssueAssigneeSchema),
-  head: GitHubPullRequestHeadSchema,
-  base: GitHubPullRequestHeadSchema,
-});
-
-const RepoParamsSchema = z.object({
-  owner: z.string().describe("Repository owner (username or organization)"),
-  repo: z.string().describe("Repository name"),
-});
-
-export const CreateOrUpdateFileSchema = RepoParamsSchema.extend({
-  path: z.string().describe("Path where to create/update the file"),
-  content: z.string().describe("Content of the file"),
-  message: z.string().describe("Commit message"),
-  branch: z.string().describe("Branch to create/update the file in"),
-  sha: z
-    .string()
-    .optional()
-    .describe(
-      "SHA of the file being replaced (required when updating existing files)"
-    ),
-});
-
-export const SearchRepositoriesSchema = z.object({
-  query: z.string().describe("Search query (see GitHub search syntax)"),
-  page: z
-    .number()
-    .optional()
-    .describe("Page number for pagination (default: 1)"),
-  perPage: z
-    .number()
-    .optional()
-    .describe("Number of results per page (default: 30, max: 100)"),
-});
-
-export const ListCommitsSchema = z.object({
-  owner: z.string().describe("Repository owner (username or organization)"),
-  repo: z.string().describe("Repository name"),
-  page: z.number().optional().describe("Page number for pagination (default: 1)"),
-  perPage: z.number().optional().describe("Number of results per page (default: 30, max: 100)"),
-  sha: z.string().optional()
-    .describe("SHA of the file being replaced (required when updating existing files)")
-});
-
-export const CreateRepositorySchema = z.object({
-  name: z.string().describe("Repository name"),
-  description: z.string().optional().describe("Repository description"),
-  private: z
-    .boolean()
-    .optional()
-    .describe("Whether the repository should be private"),
-  autoInit: z.boolean().optional().describe("Initialize with README.md"),
-});
-
-export const GetFileContentsSchema = RepoParamsSchema.extend({
-  path: z.string().describe("Path to the file or directory"),
-  branch: z.string().optional().describe("Branch to get contents from"),
-});
-
-export const PushFilesSchema = RepoParamsSchema.extend({
-  branch: z.string().describe("Branch to push to (e.g., 'main' or 'master')"),
-  files: z
-    .array(
-      z.object({
-        path: z.string().describe("Path where to create the file"),
-        content: z.string().describe("Content of the file"),
-      })
-    )
-    .describe("Array of files to push"),
-  message: z.string().describe("Commit message"),
-});
-
-export const CreateIssueSchema = RepoParamsSchema.extend({
-  title: z.string().describe("Issue title"),
-  body: z.string().optional().describe("Issue body/description"),
-  assignees: z
-    .array(z.string())
-    .optional()
-    .describe("Array of usernames to assign"),
-  labels: z.array(z.string()).optional().describe("Array of label names"),
-  milestone: z.number().optional().describe("Milestone number to assign"),
-});
-
-export const CreatePullRequestSchema = RepoParamsSchema.extend({
-  title: z.string().describe("Pull request title"),
-  body: z.string().optional().describe("Pull request body/description"),
-  head: z
-    .string()
-    .describe("The name of the branch where your changes are implemented"),
-  base: z
-    .string()
-    .describe("The name of the branch you want the changes pulled into"),
-  draft: z
-    .boolean()
-    .optional()
-    .describe("Whether to create the pull request as a draft"),
-  maintainer_can_modify: z
-    .boolean()
-    .optional()
-    .describe("Whether maintainers can modify the pull request"),
-});
-
-export const ForkRepositorySchema = RepoParamsSchema.extend({
-  organization: z
-    .string()
-    .optional()
-    .describe(
-      "Optional: organization to fork to (defaults to your personal account)"
-    ),
-});
-
-export const CreateBranchSchema = RepoParamsSchema.extend({
-  branch: z.string().describe("Name for the new branch"),
-  from_branch: z
-    .string()
-    .optional()
-    .describe(
-      "Optional: source branch to create from (defaults to the repository's default branch)"
-    ),
-});
-
-/**
- * Response schema for a code search result item
- * @see https://docs.github.com/en/rest/search/search?apiVersion=2022-11-28#search-code
- */
-export const SearchCodeItemSchema = z.object({
-  name: z.string().describe("The name of the file"),
-  path: z.string().describe("The path to the file in the repository"),
-  sha: z.string().describe("The SHA hash of the file"),
-  url: z.string().describe("The API URL for this file"),
-  git_url: z.string().describe("The Git URL for this file"),
-  html_url: z.string().describe("The HTML URL to view this file on GitHub"),
-  repository: GitHubRepositorySchema.describe(
-    "The repository where this file was found"
-  ),
-  score: z.number().describe("The search result score"),
-});
-
-/**
- * Response schema for code search results
- */
-export const SearchCodeResponseSchema = z.object({
-  total_count: z.number().describe("Total number of matching results"),
-  incomplete_results: z
-    .boolean()
-    .describe("Whether the results are incomplete"),
-  items: z.array(SearchCodeItemSchema).describe("The search results"),
-});
-
-/**
- * Response schema for an issue search result item
- * @see https://docs.github.com/en/rest/search/search?apiVersion=2022-11-28#search-issues-and-pull-requests
- */
-export const SearchIssueItemSchema = z.object({
-  url: z.string().describe("The API URL for this issue"),
-  repository_url: z
-    .string()
-    .describe("The API URL for the repository where this issue was found"),
-  labels_url: z.string().describe("The API URL for the labels of this issue"),
-  comments_url: z.string().describe("The API URL for comments of this issue"),
-  events_url: z.string().describe("The API URL for events of this issue"),
-  html_url: z.string().describe("The HTML URL to view this issue on GitHub"),
-  id: z.number().describe("The ID of this issue"),
-  node_id: z.string().describe("The Node ID of this issue"),
-  number: z.number().describe("The number of this issue"),
-  title: z.string().describe("The title of this issue"),
-  user: GitHubIssueAssigneeSchema.describe("The user who created this issue"),
-  labels: z.array(GitHubLabelSchema).describe("The labels of this issue"),
-  state: z.string().describe("The state of this issue"),
-  locked: z.boolean().describe("Whether this issue is locked"),
-  assignee: GitHubIssueAssigneeSchema.nullable().describe(
-    "The assignee of this issue"
-  ),
-  assignees: z
-    .array(GitHubIssueAssigneeSchema)
-    .describe("The assignees of this issue"),
-  comments: z.number().describe("The number of comments on this issue"),
-  created_at: z.string().describe("The creation time of this issue"),
-  updated_at: z.string().describe("The last update time of this issue"),
-  closed_at: z.string().nullable().describe("The closure time of this issue"),
-  body: z.string().describe("The body of this issue"),
-  score: z.number().describe("The search result score"),
-  pull_request: z
-    .object({
-      url: z.string().describe("The API URL for this pull request"),
-      html_url: z.string().describe("The HTML URL to view this pull request"),
-      diff_url: z.string().describe("The URL to view the diff"),
-      patch_url: z.string().describe("The URL to view the patch"),
-    })
-    .optional()
-    .describe("Pull request details if this is a PR"),
-});
-
-/**
- * Response schema for issue search results
- */
-export const SearchIssuesResponseSchema = z.object({
-  total_count: z.number().describe("Total number of matching results"),
-  incomplete_results: z
-    .boolean()
-    .describe("Whether the results are incomplete"),
-  items: z.array(SearchIssueItemSchema).describe("The search results"),
-});
-
-/**
- * Response schema for a user search result item
- * @see https://docs.github.com/en/rest/search/search?apiVersion=2022-11-28#search-users
- */
-export const SearchUserItemSchema = z.object({
-  login: z.string().describe("The username of the user"),
-  id: z.number().describe("The ID of the user"),
-  node_id: z.string().describe("The Node ID of the user"),
-  avatar_url: z.string().describe("The avatar URL of the user"),
-  gravatar_id: z.string().describe("The Gravatar ID of the user"),
-  url: z.string().describe("The API URL for this user"),
-  html_url: z.string().describe("The HTML URL to view this user on GitHub"),
-  followers_url: z.string().describe("The API URL for followers of this user"),
-  following_url: z.string().describe("The API URL for following of this user"),
-  gists_url: z.string().describe("The API URL for gists of this user"),
-  starred_url: z
-    .string()
-    .describe("The API URL for starred repositories of this user"),
-  subscriptions_url: z
-    .string()
-    .describe("The API URL for subscriptions of this user"),
-  organizations_url: z
-    .string()
-    .describe("The API URL for organizations of this user"),
-  repos_url: z.string().describe("The API URL for repositories of this user"),
-  events_url: z.string().describe("The API URL for events of this user"),
-  received_events_url: z
-    .string()
-    .describe("The API URL for received events of this user"),
-  type: z.string().describe("The type of this user"),
-  site_admin: z.boolean().describe("Whether this user is a site administrator"),
-  score: z.number().describe("The search result score"),
-});
-
-/**
- * Response schema for user search results
- */
-export const SearchUsersResponseSchema = z.object({
-  total_count: z.number().describe("Total number of matching results"),
-  incomplete_results: z
-    .boolean()
-    .describe("Whether the results are incomplete"),
-  items: z.array(SearchUserItemSchema).describe("The search results"),
-});
-
-/**
- * Input schema for code search
- * @see https://docs.github.com/en/rest/search/search?apiVersion=2022-11-28#search-code--parameters
- */
-export const SearchCodeSchema = z.object({
-  q: z
-    .string()
-    .describe(
-      "Search query. See GitHub code search syntax: https://docs.github.com/en/search-github/searching-on-github/searching-code"
-    ),
-  order: z
-    .enum(["asc", "desc"])
-    .optional()
-    .describe("Sort order (asc or desc)"),
-  per_page: z
-    .number()
-    .min(1)
-    .max(100)
-    .optional()
-    .describe("Results per page (max 100)"),
-  page: z.number().min(1).optional().describe("Page number"),
-});
-
-/**
- * Input schema for issues search
- * @see https://docs.github.com/en/rest/search/search?apiVersion=2022-11-28#search-issues-and-pull-requests--parameters
- */
-export const SearchIssuesSchema = z.object({
-  q: z
-    .string()
-    .describe(
-      "Search query. See GitHub issues search syntax: https://docs.github.com/en/search-github/searching-on-github/searching-issues-and-pull-requests"
-    ),
-  sort: z
-    .enum([
-      "comments",
-      "reactions",
-      "reactions-+1",
-      "reactions--1",
-      "reactions-smile",
-      "reactions-thinking_face",
-      "reactions-heart",
-      "reactions-tada",
-      "interactions",
-      "created",
-      "updated",
-    ])
-    .optional()
-    .describe("Sort field"),
-  order: z
-    .enum(["asc", "desc"])
-    .optional()
-    .describe("Sort order (asc or desc)"),
-  per_page: z
-    .number()
-    .min(1)
-    .max(100)
-    .optional()
-    .describe("Results per page (max 100)"),
-  page: z.number().min(1).optional().describe("Page number"),
-});
-
-/**
- * Input schema for users search
- * @see https://docs.github.com/en/rest/search/search?apiVersion=2022-11-28#search-users--parameters
- */
-export const SearchUsersSchema = z.object({
-  q: z
-    .string()
-    .describe(
-      "Search query. See GitHub users search syntax: https://docs.github.com/en/search-github/searching-on-github/searching-users"
-    ),
-  sort: z
-    .enum(["followers", "repositories", "joined"])
-    .optional()
-    .describe("Sort field"),
-  order: z
-    .enum(["asc", "desc"])
-    .optional()
-    .describe("Sort order (asc or desc)"),
-  per_page: z
-    .number()
-    .min(1)
-    .max(100)
-    .optional()
-    .describe("Results per page (max 100)"),
-  page: z.number().min(1).optional().describe("Page number"),
-});
-
-// Add these schema definitions for issue management
-
-export const ListIssuesOptionsSchema = z.object({
-  owner: z.string(),
-  repo: z.string(),
-  state: z.enum(['open', 'closed', 'all']).optional(),
-  labels: z.array(z.string()).optional(),
-  sort: z.enum(['created', 'updated', 'comments']).optional(),
-  direction: z.enum(['asc', 'desc']).optional(),
-  since: z.string().optional(), // ISO 8601 timestamp
-  page: z.number().optional(),
-  per_page: z.number().optional()
-});
-
-export const UpdateIssueOptionsSchema = z.object({
-  owner: z.string(),
-  repo: z.string(),
-  issue_number: z.number(),
-  title: z.string().optional(),
-  body: z.string().optional(),
-  state: z.enum(['open', 'closed']).optional(),
-  labels: z.array(z.string()).optional(),
-  assignees: z.array(z.string()).optional(),
-  milestone: z.number().optional()
-});
-
-export const IssueCommentSchema = z.object({
-  owner: z.string(),
-  repo: z.string(),
-  issue_number: z.number(),
-  body: z.string()
-});
-
-export const GetIssueSchema = z.object({
-  owner: z.string().describe("Repository owner (username or organization)"),
-  repo: z.string().describe("Repository name"),
-  issue_number: z.number().describe("Issue number")
-});
-
-// Export types
-export type GitHubAuthor = z.infer<typeof GitHubAuthorSchema>;
-export type GitHubFork = z.infer<typeof GitHubForkSchema>;
-export type GitHubIssue = z.infer<typeof GitHubIssueSchema>;
-export type GitHubPullRequest = z.infer<typeof GitHubPullRequestSchema>;
-export type GitHubRepository = z.infer<typeof GitHubRepositorySchema>;
-export type GitHubFileContent = z.infer<typeof GitHubFileContentSchema>;
-export type GitHubDirectoryContent = z.infer<
-  typeof GitHubDirectoryContentSchema
->;
-export type GitHubContent = z.infer<typeof GitHubContentSchema>;
-export type FileOperation = z.infer<typeof FileOperationSchema>;
-export type GitHubTree = z.infer<typeof GitHubTreeSchema>;
-export type GitHubCommit = z.infer<typeof GitHubCommitSchema>;
-export type GitHubListCommits = z.infer<typeof GitHubListCommitsSchema>;
-export type GitHubReference = z.infer<typeof GitHubReferenceSchema>;
-export type CreateRepositoryOptions = z.infer<
-  typeof CreateRepositoryOptionsSchema
->;
-export type CreateIssueOptions = z.infer<typeof CreateIssueOptionsSchema>;
-export type CreatePullRequestOptions = z.infer<
-  typeof CreatePullRequestOptionsSchema
->;
-export type CreateBranchOptions = z.infer<typeof CreateBranchOptionsSchema>;
-export type GitHubCreateUpdateFileResponse = z.infer<
-  typeof GitHubCreateUpdateFileResponseSchema
->;
-export type GitHubSearchResponse = z.infer<typeof GitHubSearchResponseSchema>;
-export type SearchCodeItem = z.infer<typeof SearchCodeItemSchema>;
-export type SearchCodeResponse = z.infer<typeof SearchCodeResponseSchema>;
-export type SearchIssueItem = z.infer<typeof SearchIssueItemSchema>;
-export type SearchIssuesResponse = z.infer<typeof SearchIssuesResponseSchema>;
-export type SearchUserItem = z.infer<typeof SearchUserItemSchema>;
-export type SearchUsersResponse = z.infer<typeof SearchUsersResponseSchema>;