diff --git a/src/github/common/errors.ts b/src/github/common/errors.ts
new file mode 100644
index 00000000..5b940f3b
--- /dev/null
+++ b/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
+      );
+  }
+}
\ No newline at end of file
diff --git a/src/github/common/types.ts b/src/github/common/types.ts
new file mode 100644
index 00000000..af81f22f
--- /dev/null
+++ b/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>;
\ No newline at end of file
diff --git a/src/github/common/utils.ts b/src/github/common/utils.ts
new file mode 100644
index 00000000..21c8aa71
--- /dev/null
+++ b/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;
+  }
+}
\ No newline at end of file
diff --git a/src/github/index.ts b/src/github/index.ts
index 3759e8b5..fd77f017 100644
--- a/src/github/index.ts
+++ b/src/github/index.ts
@@ -5,61 +5,26 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import fetch from "node-fetch";
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import * as repository from './operations/repository.js';
+import * as files from './operations/files.js';
+import * as issues from './operations/issues.js';
+import * as pulls from './operations/pulls.js';
+import * as branches from './operations/branches.js';
+import * as search from './operations/search.js';
+import * as commits from './operations/commits.js';
 import {
-  CreateBranchOptionsSchema,
-  CreateBranchSchema,
-  CreateIssueOptionsSchema,
-  CreateIssueSchema,
-  CreateOrUpdateFileSchema,
-  CreatePullRequestOptionsSchema,
-  CreatePullRequestSchema,
-  CreateRepositoryOptionsSchema,
-  CreateRepositorySchema,
-  ForkRepositorySchema,
-  GetFileContentsSchema,
-  GetIssueSchema,
-  GitHubCommitSchema,
-  GitHubContentSchema,
-  GitHubCreateUpdateFileResponseSchema,
-  GitHubForkSchema,
-  GitHubIssueSchema,
-  GitHubListCommits,
-  GitHubListCommitsSchema,
-  GitHubPullRequestSchema,
-  GitHubReferenceSchema,
-  GitHubRepositorySchema,
-  GitHubSearchResponseSchema,
-  GitHubTreeSchema,
-  IssueCommentSchema,
-  ListCommitsSchema,
-  ListIssuesOptionsSchema,
-  PushFilesSchema,
-  SearchCodeResponseSchema,
-  SearchCodeSchema,
-  SearchIssuesResponseSchema,
-  SearchIssuesSchema,
-  SearchRepositoriesSchema,
-  SearchUsersResponseSchema,
-  SearchUsersSchema,
-  UpdateIssueOptionsSchema,
-  type FileOperation,
-  type GitHubCommit,
-  type GitHubContent,
-  type GitHubCreateUpdateFileResponse,
-  type GitHubFork,
-  type GitHubIssue,
-  type GitHubPullRequest,
-  type GitHubReference,
-  type GitHubRepository,
-  type GitHubSearchResponse,
-  type GitHubTree,
-  type SearchCodeResponse,
-  type SearchIssuesResponse,
-  type SearchUsersResponse
-} from './schemas.js';
+  GitHubError,
+  GitHubValidationError,
+  GitHubResourceNotFoundError,
+  GitHubAuthenticationError,
+  GitHubPermissionError,
+  GitHubRateLimitError,
+  GitHubConflictError,
+  isGitHubError,
+} from './common/errors.js';
 
 const server = new Server(
   {
@@ -73,646 +38,27 @@ const server = new Server(
   }
 );
 
-const GITHUB_PERSONAL_ACCESS_TOKEN = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
-
-if (!GITHUB_PERSONAL_ACCESS_TOKEN) {
-  console.error("GITHUB_PERSONAL_ACCESS_TOKEN environment variable is not set");
-  process.exit(1);
-}
-
-async function forkRepository(
-  owner: string,
-  repo: string,
-  organization?: string
-): Promise<GitHubFork> {
-  const url = organization
-    ? `https://api.github.com/repos/${owner}/${repo}/forks?organization=${organization}`
-    : `https://api.github.com/repos/${owner}/${repo}/forks`;
-
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubForkSchema.parse(await response.json());
-}
-
-async function createBranch(
-  owner: string,
-  repo: string,
-  options: z.infer<typeof CreateBranchOptionsSchema>
-): Promise<GitHubReference> {
-  const fullRef = `refs/heads/${options.ref}`;
-
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/git/refs`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        ref: fullRef,
-        sha: options.sha,
-      }),
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubReferenceSchema.parse(await response.json());
-}
-
-async function getDefaultBranchSHA(
-  owner: string,
-  repo: string
-): Promise<string> {
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/main`,
-    {
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-      },
-    }
-  );
-
-  if (!response.ok) {
-    const masterResponse = await fetch(
-      `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/master`,
-      {
-        headers: {
-          Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-          Accept: "application/vnd.github.v3+json",
-          "User-Agent": "github-mcp-server",
-        },
-      }
-    );
-
-    if (!masterResponse.ok) {
-      throw new Error(
-        "Could not find default branch (tried 'main' and 'master')"
-      );
-    }
-
-    const data = GitHubReferenceSchema.parse(await masterResponse.json());
-    return data.object.sha;
-  }
-
-  const data = GitHubReferenceSchema.parse(await response.json());
-  return data.object.sha;
-}
-
-async function getFileContents(
-  owner: string,
-  repo: string,
-  path: string,
-  branch?: string
-): Promise<GitHubContent> {
-  let url = `https://api.github.com/repos/${owner}/${repo}/contents/${path}`;
-  if (branch) {
-    url += `?ref=${branch}`;
-  }
-
-  const response = await fetch(url, {
-    headers: {
-      Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  const data = GitHubContentSchema.parse(await response.json());
-
-  // 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;
-}
-
-async function createIssue(
-  owner: string,
-  repo: string,
-  options: z.infer<typeof CreateIssueOptionsSchema>
-): Promise<GitHubIssue> {
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/issues`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(options),
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubIssueSchema.parse(await response.json());
-}
-
-async function createPullRequest(
-  owner: string,
-  repo: string,
-  options: z.infer<typeof CreatePullRequestOptionsSchema>
-): Promise<GitHubPullRequest> {
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/pulls`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(options),
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubPullRequestSchema.parse(await response.json());
-}
-
-async function createOrUpdateFile(
-  owner: string,
-  repo: string,
-  path: string,
-  content: string,
-  message: string,
-  branch: string,
-  sha?: string
-): Promise<GitHubCreateUpdateFileResponse> {
-  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 fetch(url, {
-    method: "PUT",
-    headers: {
-      Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server",
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubCreateUpdateFileResponseSchema.parse(await response.json());
-}
-
-async function createTree(
-  owner: string,
-  repo: string,
-  files: FileOperation[],
-  baseTree?: string
-): Promise<GitHubTree> {
-  const tree = files.map((file) => ({
-    path: file.path,
-    mode: "100644" as const,
-    type: "blob" as const,
-    content: file.content,
-  }));
-
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/git/trees`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        tree,
-        base_tree: baseTree,
-      }),
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubTreeSchema.parse(await response.json());
-}
-
-async function createCommit(
-  owner: string,
-  repo: string,
-  message: string,
-  tree: string,
-  parents: string[]
-): Promise<GitHubCommit> {
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/git/commits`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        message,
-        tree,
-        parents,
-      }),
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubCommitSchema.parse(await response.json());
-}
-
-async function updateReference(
-  owner: string,
-  repo: string,
-  ref: string,
-  sha: string
-): Promise<GitHubReference> {
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/git/refs/${ref}`,
-    {
-      method: "PATCH",
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        sha,
-        force: true,
-      }),
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubReferenceSchema.parse(await response.json());
-}
-
-async function pushFiles(
-  owner: string,
-  repo: string,
-  branch: string,
-  files: FileOperation[],
-  message: string
-): Promise<GitHubReference> {
-  const refResponse = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`,
-    {
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-      },
-    }
-  );
-
-  if (!refResponse.ok) {
-    throw new Error(`GitHub API error: ${refResponse.statusText}`);
-  }
-
-  const ref = GitHubReferenceSchema.parse(await refResponse.json());
-  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);
-}
-
-async function searchRepositories(
-  query: string,
-  page: number = 1,
-  perPage: number = 30
-): Promise<GitHubSearchResponse> {
-  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 fetch(url.toString(), {
-    headers: {
-      Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubSearchResponseSchema.parse(await response.json());
-}
-
-async function createRepository(
-  options: z.infer<typeof CreateRepositoryOptionsSchema>
-): Promise<GitHubRepository> {
-  const response = await fetch("https://api.github.com/user/repos", {
-    method: "POST",
-    headers: {
-      Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server",
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(options),
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubRepositorySchema.parse(await response.json());
-}
-
-async function listCommits(
-  owner: string,
-  repo: string,
-  page: number = 1,
-  perPage: number = 30,
-  sha?: string,
-): Promise<GitHubListCommits> {
-  const url = new URL(`https://api.github.com/repos/${owner}/${repo}/commits`);
-  url.searchParams.append("page", page.toString());
-  url.searchParams.append("per_page", perPage.toString());
-  if (sha) {
-    url.searchParams.append("sha", sha);
-  }
-
-  const response = await fetch(
-    url.toString(),
-    {
-      method: "GET",
-      headers: {
-        "Authorization": `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json"
-      },
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubListCommitsSchema.parse(await response.json());
-}
-
-async function listIssues(
-  owner: string,
-  repo: string,
-  options: Omit<z.infer<typeof ListIssuesOptionsSchema>, 'owner' | 'repo'>
-): Promise<GitHubIssue[]> {
-  const url = new URL(`https://api.github.com/repos/${owner}/${repo}/issues`);
-
-  // Add query parameters
-  if (options.state) url.searchParams.append('state', options.state);
-  if (options.labels) url.searchParams.append('labels', options.labels.join(','));
-  if (options.sort) url.searchParams.append('sort', options.sort);
-  if (options.direction) url.searchParams.append('direction', options.direction);
-  if (options.since) url.searchParams.append('since', options.since);
-  if (options.page) url.searchParams.append('page', options.page.toString());
-  if (options.per_page) url.searchParams.append('per_page', options.per_page.toString());
-
-  const response = await fetch(url.toString(), {
-    headers: {
-      "Authorization": `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      "Accept": "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server"
-    }
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return z.array(GitHubIssueSchema).parse(await response.json());
-}
-
-async function updateIssue(
-  owner: string,
-  repo: string,
-  issueNumber: number,
-  options: Omit<z.infer<typeof UpdateIssueOptionsSchema>, 'owner' | 'repo' | 'issue_number'>
-): Promise<GitHubIssue> {
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`,
-    {
-      method: "PATCH",
-      headers: {
-        "Authorization": `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        title: options.title,
-        body: options.body,
-        state: options.state,
-        labels: options.labels,
-        assignees: options.assignees,
-        milestone: options.milestone
-      })
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return GitHubIssueSchema.parse(await response.json());
-}
-
-async function addIssueComment(
-  owner: string,
-  repo: string,
-  issueNumber: number,
-  body: string
-): Promise<z.infer<typeof IssueCommentSchema>> {
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
-    {
-      method: "POST",
-      headers: {
-        "Authorization": `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ body })
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return IssueCommentSchema.parse(await response.json());
-}
-
-async function searchCode(
-  params: z.infer<typeof SearchCodeSchema>
-): Promise<SearchCodeResponse> {
-  const url = new URL("https://api.github.com/search/code");
-  Object.entries(params).forEach(([key, value]) => {
-    if (value !== undefined && value !== null) {
-      url.searchParams.append(key, value.toString());
-    }
-  });
-
-  const response = await fetch(url.toString(), {
-    headers: {
-      Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return SearchCodeResponseSchema.parse(await response.json());
-}
-
-async function searchIssues(
-  params: z.infer<typeof SearchIssuesSchema>
-): Promise<SearchIssuesResponse> {
-  const url = new URL("https://api.github.com/search/issues");
-  Object.entries(params).forEach(([key, value]) => {
-    if (value !== undefined && value !== null) {
-      url.searchParams.append(key, value.toString());
+function formatGitHubError(error: GitHubError): string {
+  let message = `GitHub API Error: ${error.message}`;
+  
+  if (error instanceof GitHubValidationError) {
+    message = `Validation Error: ${error.message}`;
+    if (error.response) {
+      message += `\nDetails: ${JSON.stringify(error.response)}`;
     }
-  });
-
-  const response = await fetch(url.toString(), {
-    headers: {
-      Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return SearchIssuesResponseSchema.parse(await response.json());
-}
-
-async function searchUsers(
-  params: z.infer<typeof SearchUsersSchema>
-): Promise<SearchUsersResponse> {
-  const url = new URL("https://api.github.com/search/users");
-  Object.entries(params).forEach(([key, value]) => {
-    if (value !== undefined && value !== null) {
-      url.searchParams.append(key, value.toString());
-    }
-  });
-
-  const response = await fetch(url.toString(), {
-    headers: {
-      Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "github-mcp-server",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.statusText}`);
-  }
-
-  return SearchUsersResponseSchema.parse(await response.json());
-}
-
-async function getIssue(
-  owner: string,
-  repo: string,
-  issueNumber: number
-): Promise<GitHubIssue> {
-  const response = await fetch(
-    `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`,
-    {
-      headers: {
-        Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "github-mcp-server",
-      },
-    }
-);
-
-  if (!response.ok) {
-    throw new Error(`Github API error: ${response.statusText}`);
+  } else if (error instanceof GitHubResourceNotFoundError) {
+    message = `Not Found: ${error.message}`;
+  } else if (error instanceof GitHubAuthenticationError) {
+    message = `Authentication Failed: ${error.message}`;
+  } else if (error instanceof GitHubPermissionError) {
+    message = `Permission Denied: ${error.message}`;
+  } else if (error instanceof GitHubRateLimitError) {
+    message = `Rate Limit Exceeded: ${error.message}\nResets at: ${error.resetAt.toISOString()}`;
+  } else if (error instanceof GitHubConflictError) {
+    message = `Conflict: ${error.message}`;
   }
 
-  return GitHubIssueSchema.parse(await response.json());
+  return message;
 }
 
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -721,91 +67,87 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       {
         name: "create_or_update_file",
         description: "Create or update a single file in a GitHub repository",
-        inputSchema: zodToJsonSchema(CreateOrUpdateFileSchema),
+        inputSchema: zodToJsonSchema(files.CreateOrUpdateFileSchema),
       },
       {
         name: "search_repositories",
         description: "Search for GitHub repositories",
-        inputSchema: zodToJsonSchema(SearchRepositoriesSchema),
+        inputSchema: zodToJsonSchema(repository.SearchRepositoriesSchema),
       },
       {
         name: "create_repository",
         description: "Create a new GitHub repository in your account",
-        inputSchema: zodToJsonSchema(CreateRepositorySchema),
+        inputSchema: zodToJsonSchema(repository.CreateRepositoryOptionsSchema),
       },
       {
         name: "get_file_contents",
-        description:
-          "Get the contents of a file or directory from a GitHub repository",
-        inputSchema: zodToJsonSchema(GetFileContentsSchema),
+        description: "Get the contents of a file or directory from a GitHub repository",
+        inputSchema: zodToJsonSchema(files.GetFileContentsSchema),
       },
       {
         name: "push_files",
-        description:
-          "Push multiple files to a GitHub repository in a single commit",
-        inputSchema: zodToJsonSchema(PushFilesSchema),
+        description: "Push multiple files to a GitHub repository in a single commit",
+        inputSchema: zodToJsonSchema(files.PushFilesSchema),
       },
       {
         name: "create_issue",
         description: "Create a new issue in a GitHub repository",
-        inputSchema: zodToJsonSchema(CreateIssueSchema),
+        inputSchema: zodToJsonSchema(issues.CreateIssueSchema),
       },
       {
         name: "create_pull_request",
         description: "Create a new pull request in a GitHub repository",
-        inputSchema: zodToJsonSchema(CreatePullRequestSchema),
+        inputSchema: zodToJsonSchema(pulls.CreatePullRequestSchema),
       },
       {
         name: "fork_repository",
-        description:
-          "Fork a GitHub repository to your account or specified organization",
-        inputSchema: zodToJsonSchema(ForkRepositorySchema),
+        description: "Fork a GitHub repository to your account or specified organization",
+        inputSchema: zodToJsonSchema(repository.ForkRepositorySchema),
       },
       {
         name: "create_branch",
         description: "Create a new branch in a GitHub repository",
-        inputSchema: zodToJsonSchema(CreateBranchSchema),
+        inputSchema: zodToJsonSchema(branches.CreateBranchSchema),
       },
       {
         name: "list_commits",
         description: "Get list of commits of a branch in a GitHub repository",
-        inputSchema: zodToJsonSchema(ListCommitsSchema)
+        inputSchema: zodToJsonSchema(commits.ListCommitsSchema)
       },
       {
         name: "list_issues",
         description: "List issues in a GitHub repository with filtering options",
-        inputSchema: zodToJsonSchema(ListIssuesOptionsSchema)
+        inputSchema: zodToJsonSchema(issues.ListIssuesOptionsSchema)
       },
       {
         name: "update_issue",
         description: "Update an existing issue in a GitHub repository",
-        inputSchema: zodToJsonSchema(UpdateIssueOptionsSchema)
+        inputSchema: zodToJsonSchema(issues.UpdateIssueOptionsSchema)
       },
       {
         name: "add_issue_comment",
         description: "Add a comment to an existing issue",
-        inputSchema: zodToJsonSchema(IssueCommentSchema)
+        inputSchema: zodToJsonSchema(issues.IssueCommentSchema)
       },
       {
         name: "search_code",
         description: "Search for code across GitHub repositories",
-        inputSchema: zodToJsonSchema(SearchCodeSchema),
+        inputSchema: zodToJsonSchema(search.SearchCodeSchema),
       },
       {
         name: "search_issues",
-        description:
-          "Search for issues and pull requests across GitHub repositories",
-        inputSchema: zodToJsonSchema(SearchIssuesSchema),
+        description: "Search for issues and pull requests across GitHub repositories",
+        inputSchema: zodToJsonSchema(search.SearchIssuesSchema),
       },
       {
         name: "search_users",
         description: "Search for users on GitHub",
-        inputSchema: zodToJsonSchema(SearchUsersSchema),
+        inputSchema: zodToJsonSchema(search.SearchUsersSchema),
       },
       {
         name: "get_issue",
         description: "Get details of a specific issue in a GitHub repository.",
-        inputSchema: zodToJsonSchema(GetIssueSchema)
+        inputSchema: zodToJsonSchema(issues.GetIssueSchema)
       }
     ],
   };
@@ -819,55 +161,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     switch (request.params.name) {
       case "fork_repository": {
-        const args = ForkRepositorySchema.parse(request.params.arguments);
-        const fork = await forkRepository(
-          args.owner,
-          args.repo,
-          args.organization
-        );
+        const args = repository.ForkRepositorySchema.parse(request.params.arguments);
+        const fork = await repository.forkRepository(args.owner, args.repo, args.organization);
         return {
           content: [{ type: "text", text: JSON.stringify(fork, null, 2) }],
         };
       }
 
       case "create_branch": {
-        const args = CreateBranchSchema.parse(request.params.arguments);
-        let sha: string;
-        if (args.from_branch) {
-          const response = await fetch(
-            `https://api.github.com/repos/${args.owner}/${args.repo}/git/refs/heads/${args.from_branch}`,
-            {
-              headers: {
-                Authorization: `token ${GITHUB_PERSONAL_ACCESS_TOKEN}`,
-                Accept: "application/vnd.github.v3+json",
-                "User-Agent": "github-mcp-server",
-              },
-            }
-          );
-
-          if (!response.ok) {
-            throw new Error(`Source branch '${args.from_branch}' not found`);
-          }
-
-          const data = GitHubReferenceSchema.parse(await response.json());
-          sha = data.object.sha;
-        } else {
-          sha = await getDefaultBranchSHA(args.owner, args.repo);
-        }
-
-        const branch = await createBranch(args.owner, args.repo, {
-          ref: args.branch,
-          sha,
-        });
-
+        const args = branches.CreateBranchSchema.parse(request.params.arguments);
+        const branch = await branches.createBranchFromRef(
+          args.owner,
+          args.repo,
+          args.branch,
+          args.from_branch
+        );
         return {
           content: [{ type: "text", text: JSON.stringify(branch, null, 2) }],
         };
       }
 
       case "search_repositories": {
-        const args = SearchRepositoriesSchema.parse(request.params.arguments);
-        const results = await searchRepositories(
+        const args = repository.SearchRepositoriesSchema.parse(request.params.arguments);
+        const results = await repository.searchRepositories(
           args.query,
           args.page,
           args.perPage
@@ -878,18 +194,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case "create_repository": {
-        const args = CreateRepositorySchema.parse(request.params.arguments);
-        const repository = await createRepository(args);
+        const args = repository.CreateRepositoryOptionsSchema.parse(request.params.arguments);
+        const result = await repository.createRepository(args);
         return {
-          content: [
-            { type: "text", text: JSON.stringify(repository, null, 2) },
-          ],
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
       }
 
       case "get_file_contents": {
-        const args = GetFileContentsSchema.parse(request.params.arguments);
-        const contents = await getFileContents(
+        const args = files.GetFileContentsSchema.parse(request.params.arguments);
+        const contents = await files.getFileContents(
           args.owner,
           args.repo,
           args.path,
@@ -901,8 +215,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case "create_or_update_file": {
-        const args = CreateOrUpdateFileSchema.parse(request.params.arguments);
-        const result = await createOrUpdateFile(
+        const args = files.CreateOrUpdateFileSchema.parse(request.params.arguments);
+        const result = await files.createOrUpdateFile(
           args.owner,
           args.repo,
           args.path,
@@ -917,8 +231,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case "push_files": {
-        const args = PushFilesSchema.parse(request.params.arguments);
-        const result = await pushFiles(
+        const args = files.PushFilesSchema.parse(request.params.arguments);
+        const result = await files.pushFiles(
           args.owner,
           args.repo,
           args.branch,
@@ -931,83 +245,84 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case "create_issue": {
-        const args = CreateIssueSchema.parse(request.params.arguments);
+        const args = issues.CreateIssueSchema.parse(request.params.arguments);
         const { owner, repo, ...options } = args;
-        const issue = await createIssue(owner, repo, options);
+        const issue = await issues.createIssue(owner, repo, options);
         return {
           content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
         };
       }
 
       case "create_pull_request": {
-        const args = CreatePullRequestSchema.parse(request.params.arguments);
-        const { owner, repo, ...options } = args;
-        const pullRequest = await createPullRequest(owner, repo, options);
+        const args = pulls.CreatePullRequestSchema.parse(request.params.arguments);
+        const pullRequest = await pulls.createPullRequest(args);
         return {
-          content: [
-            { type: "text", text: JSON.stringify(pullRequest, null, 2) },
-          ],
+          content: [{ type: "text", text: JSON.stringify(pullRequest, null, 2) }],
         };
       }
 
       case "search_code": {
-        const args = SearchCodeSchema.parse(request.params.arguments);
-        const results = await searchCode(args);
+        const args = search.SearchCodeSchema.parse(request.params.arguments);
+        const results = await search.searchCode(args);
         return {
           content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
         };
       }
 
       case "search_issues": {
-        const args = SearchIssuesSchema.parse(request.params.arguments);
-        const results = await searchIssues(args);
+        const args = search.SearchIssuesSchema.parse(request.params.arguments);
+        const results = await search.searchIssues(args);
         return {
           content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
         };
       }
 
       case "search_users": {
-        const args = SearchUsersSchema.parse(request.params.arguments);
-        const results = await searchUsers(args);
+        const args = search.SearchUsersSchema.parse(request.params.arguments);
+        const results = await search.searchUsers(args);
         return {
           content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
         };
       }
 
       case "list_issues": {
-        const args = ListIssuesOptionsSchema.parse(request.params.arguments);
+        const args = issues.ListIssuesOptionsSchema.parse(request.params.arguments);
         const { owner, repo, ...options } = args;
-        const issues = await listIssues(owner, repo, options);
-        return { toolResult: issues };
+        const result = await issues.listIssues(owner, repo, options);
+        return { toolResult: result };
       }
 
       case "update_issue": {
-        const args = UpdateIssueOptionsSchema.parse(request.params.arguments);
+        const args = issues.UpdateIssueOptionsSchema.parse(request.params.arguments);
         const { owner, repo, issue_number, ...options } = args;
-        const issue = await updateIssue(owner, repo, issue_number, options);
-        return { toolResult: issue };
+        const result = await issues.updateIssue(owner, repo, issue_number, options);
+        return { toolResult: result };
       }
 
       case "add_issue_comment": {
-        const args = IssueCommentSchema.parse(request.params.arguments);
+        const args = issues.IssueCommentSchema.parse(request.params.arguments);
         const { owner, repo, issue_number, body } = args;
-        const comment = await addIssueComment(owner, repo, issue_number, body);
-        return { toolResult: comment };
+        const result = await issues.addIssueComment(owner, repo, issue_number, body);
+        return { toolResult: result };
       }
 
       case "list_commits": {
-        const args = ListCommitsSchema.parse(request.params.arguments);
-        const results = await listCommits(args.owner, args.repo, args.page, args.perPage, args.sha);
-        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        const args = commits.ListCommitsSchema.parse(request.params.arguments);
+        const results = await commits.listCommits(
+          args.owner,
+          args.repo,
+          args.page,
+          args.perPage,
+          args.sha
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        };
       }
 
       case "get_issue": {
-        const args = z.object({
-          owner: z.string(),
-          repo: z.string(),
-          issue_number: z.number()
-        }).parse(request.params.arguments);
-        const issue = await getIssue(args.owner, args.repo, args.issue_number);
+        const args = issues.GetIssueSchema.parse(request.params.arguments);
+        const issue = await issues.getIssue(args.owner, args.repo, args.issue_number);
         return { toolResult: issue };
       }
 
@@ -1016,14 +331,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
   } catch (error) {
     if (error instanceof z.ZodError) {
-      throw new Error(
-        `Invalid arguments: ${error.errors
-          .map(
-            (e: z.ZodError["errors"][number]) =>
-              `${e.path.join(".")}: ${e.message}`
-          )
-          .join(", ")}`
-      );
+      throw new Error(`Invalid input: ${JSON.stringify(error.errors)}`);
+    }
+    if (isGitHubError(error)) {
+      throw new Error(formatGitHubError(error));
     }
     throw error;
   }
@@ -1038,4 +349,4 @@ async function runServer() {
 runServer().catch((error) => {
   console.error("Fatal error in main():", error);
   process.exit(1);
-});
+});
\ No newline at end of file
diff --git a/src/github/operations/branches.ts b/src/github/operations/branches.ts
new file mode 100644
index 00000000..9b7033b5
--- /dev/null
+++ b/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);
+}
diff --git a/src/github/operations/commits.ts b/src/github/operations/commits.ts
new file mode 100644
index 00000000..b10e1b5f
--- /dev/null
+++ b/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
+    })
+  );
+}
\ No newline at end of file
diff --git a/src/github/operations/files.ts b/src/github/operations/files.ts
new file mode 100644
index 00000000..9517946e
--- /dev/null
+++ b/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);
+}
diff --git a/src/github/operations/issues.ts b/src/github/operations/issues.ts
new file mode 100644
index 00000000..d2907bf7
--- /dev/null
+++ b/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,
+    }
+  );
+}
\ No newline at end of file
diff --git a/src/github/operations/pulls.ts b/src/github/operations/pulls.ts
new file mode 100644
index 00000000..a3e05e63
--- /dev/null
+++ b/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;
+  }
+}
\ No newline at end of file
diff --git a/src/github/operations/repository.ts b/src/github/operations/repository.ts
new file mode 100644
index 00000000..4cf0ab9b
--- /dev/null
+++ b/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);
+}
diff --git a/src/github/operations/search.ts b/src/github/operations/search.ts
new file mode 100644
index 00000000..76faa729
--- /dev/null
+++ b/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));
+}
\ No newline at end of file
diff --git a/src/github/schemas.ts b/src/github/schemas.ts
deleted file mode 100644
index 0a322328..00000000
--- a/src/github/schemas.ts
+++ /dev/null
@@ -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>;