Function bodies 129 total

  constructor(config: GitHubConfig) {
    this.client = axios.create({
      baseURL: config.apiUrl,
      headers: {
        Authorization: generateBearerAuth(config.token),
        Accept: 'application/vnd.github+json',
        'X-GitHub-Api-Version': '2022-11-28',
      },
    });

    // Request interceptor for logging
    this.client.interceptors.request.use((request) => {
      logger.debug('GitHub API Request', {
        method: request.method,
        url: request.url,
      });
      return request;
    });

    // Response interceptor for error handling
    this.client.interceptors.response.use(
      (response) => response,
      (error: AxiosError) => {
        const status = error.response?.status;
        const message = (error.response?.data as { message?: string })?.message || error.message;

        logger.error('GitHub API Error', {
          status,
          message,
          url: error.config?.url,
        });

        throw error;
      }
    );
  }

  async listRepos(
    params: {
      type?: 'all' | 'owner' | 'public' | 'private' | 'member';
      sort?: 'created' | 'updated' | 'pushed' | 'full_name';
      per_page?: number;
      page?: number;
    } = {}
  ): Promise<Repository[]> {
    const response = await this.client.get<Repository[]>('/user/repos', { params });
    return response.data;
  }

  async listOrgRepos(
    org: string,
    params: {
      type?: 'all' | 'public' | 'private' | 'forks' | 'sources' | 'member';
      sort?: 'created' | 'updated' | 'pushed' | 'full_name';
      per_page?: number;
      page?: number;
    } = {}
  ): Promise<Repository[]> {
    const response = await this.client.get<Repository[]>(`/orgs/${org}/repos`, { params });
    return response.data;
  }

  async getRepo(owner: string, repo: string): Promise<Repository> {
    const response = await this.client.get<Repository>(`/repos/${owner}/${repo}`);
    return response.data;
  }

  async createRepo(params: {
    name: string;
    description?: string;
    private?: boolean;
    auto_init?: boolean;
  }): Promise<Repository> {
    const response = await this.client.post<Repository>('/user/repos', params);
    return response.data;
  }

  async listIssues(
    owner: string,
    repo: string,
    params: {
      state?: 'open' | 'closed' | 'all';
      labels?: string;
      sort?: 'created' | 'updated' | 'comments';
      direction?: 'asc' | 'desc';
      per_page?: number;
      page?: number;
    } = {}
  ): Promise<Issue[]> {
    const response = await this.client.get<Issue[]>(`/repos/${owner}/${repo}/issues`, { params });
    return response.data;
  }

  async getIssue(owner: string, repo: string, issueNumber: number): Promise<Issue> {
    const response = await this.client.get<Issue>(`/repos/${owner}/${repo}/issues/${issueNumber}`);
    return response.data;
  }

  async createIssue(
    owner: string,
    repo: string,
    params: {
      title: string;
      body?: string;
      labels?: string[];
      assignees?: string[];
      milestone?: number;
    }
  ): Promise<Issue> {
    const response = await this.client.post<Issue>(`/repos/${owner}/${repo}/issues`, params);
    return response.data;
  }

  async updateIssue(
    owner: string,
    repo: string,
    issueNumber: number,
    params: {
      title?: string;
      body?: string;
      state?: 'open' | 'closed';
      labels?: string[];
      assignees?: string[];
      milestone?: number | null;
    }
  ): Promise<Issue> {
    const response = await this.client.patch<Issue>(
      `/repos/${owner}/${repo}/issues/${issueNumber}`,
      params
    );
    return response.data;
  }

  async addIssueComment(
    owner: string,
    repo: string,
    issueNumber: number,
    body: string
  ): Promise<Comment> {
    const response = await this.client.post<Comment>(
      `/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
      { body }
    );
    return response.data;
  }

  async listIssueComments(
    owner: string,
    repo: string,
    issueNumber: number,
    params: {
      sort?: 'created' | 'updated';
      direction?: 'asc' | 'desc';
      since?: string;
      per_page?: number;
      page?: number;
    } = {}
  ): Promise<Comment[]> {
    const response = await this.client.get<Comment[]>(
      `/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
      { params }
    );
    return response.data;
  }

  async getIssueComment(owner: string, repo: string, commentId: number): Promise<Comment> {
    const response = await this.client.get<Comment>(
      `/repos/${owner}/${repo}/issues/comments/${commentId}`
    );
    return response.data;
  }

  async listPullRequests(
    owner: string,
    repo: string,
    params: {
      state?: 'open' | 'closed' | 'all';
      head?: string;
      base?: string;
      sort?: 'created' | 'updated' | 'popularity' | 'long-running';
      direction?: 'asc' | 'desc';
      per_page?: number;
      page?: number;
    } = {}
  ): Promise<PullRequest[]> {
    const response = await this.client.get<PullRequest[]>(`/repos/${owner}/${repo}/pulls`, {
      params,
    });
    return response.data;
  }

  async getPullRequest(owner: string, repo: string, pullNumber: number): Promise<PullRequest> {
    const response = await this.client.get<PullRequest>(
      `/repos/${owner}/${repo}/pulls/${pullNumber}`
    );
    return response.data;
  }

  async createPullRequest(
    owner: string,
    repo: string,
    params: {
      title: string;
      head: string;
      base: string;
      body?: string;
      draft?: boolean;
    }
  ): Promise<PullRequest> {
    const response = await this.client.post<PullRequest>(`/repos/${owner}/${repo}/pulls`, params);
    return response.data;
  }

  async mergePullRequest(
    owner: string,
    repo: string,
    pullNumber: number,
    params: {
      commit_title?: string;
      commit_message?: string;
      merge_method?: 'merge' | 'squash' | 'rebase';
    } = {}
  ): Promise<{ merged: boolean; message: string }> {

  async listPRFiles(
    owner: string,
    repo: string,
    pullNumber: number,
    params: { per_page?: number; page?: number } = {}
  ): Promise<PRFile[]> {
    const response = await this.client.get<PRFile[]>(
      `/repos/${owner}/${repo}/pulls/${pullNumber}/files`,
      { params }
    );
    return response.data;
  }

  async addPRComment(
    owner: string,
    repo: string,
    pullNumber: number,
    body: string
  ): Promise<Comment> {
    // PR comments use the issues endpoint
    return this.addIssueComment(owner, repo, pullNumber, body);
  }

  async listPRComments(
    owner: string,
    repo: string,
    pullNumber: number,
    params: {
      sort?: 'created' | 'updated';
      direction?: 'asc' | 'desc';
      since?: string;
      per_page?: number;
      page?: number;
    } = {}
  ): Promise<Comment[]> {
    // PR comments use the issues endpoint
    return this.listIssueComments(owner, repo, pullNumber, params);
  }

  async getPRComment(owner: string, repo: string, commentId: number): Promise<Comment> {
    // PR comments use the issues endpoint
    return this.getIssueComment(owner, repo, commentId);
  }

  async getFileContent(
    owner: string,
    repo: string,
    path: string,
    ref?: string
  ): Promise<FileContent> {
    const params = ref ? { ref } : {};
    const response = await this.client.get<FileContent>(
      `/repos/${owner}/${repo}/contents/${path}`,
      {
        params,
      }
    );
    return response.data;
  }

  async createOrUpdateFile(
    owner: string,
    repo: string,
    path: string,
    params: {
      message: string;
      content: string; // Base64 encoded content
      sha?: string; // Required for update
      branch?: string;
    }
  ): Promise<{ content: FileContent; commit: { sha: string; html_url: string } }> {

  async listDirectory(
    owner: string,
    repo: string,
    path: string = '',
    ref?: string
  ): Promise<FileContent[]> {
    const params = ref ? { ref } : {};
    const response = await this.client.get<FileContent[]>(
      `/repos/${owner}/${repo}/contents/${path}`,
      { params }
    );
    return response.data;
  }

  async listWorkflows(
    owner: string,
    repo: string,
    params: { per_page?: number; page?: number } = {}
  ): Promise<{ total_count: number; workflows: Workflow[] }> {

  async listWorkflowRuns(
    owner: string,
    repo: string,
    workflowId: number | string,
    params: {
      branch?: string;
      status?: 'queued' | 'in_progress' | 'completed';
      per_page?: number;
      page?: number;
    } = {}
  ): Promise<{ total_count: number; workflow_runs: WorkflowRun[] }> {

  async triggerWorkflow(
    owner: string,
    repo: string,
    workflowId: number | string,
    params: {
      ref: string;
      inputs?: Record<string, string>;
    }
  ): Promise<void> {
    await this.client.post(
      `/repos/${owner}/${repo}/actions/workflows/${workflowId}/dispatches`,
      params
    );
  }

  async listReleases(
    owner: string,
    repo: string,
    params: { per_page?: number; page?: number } = {}
  ): Promise<Release[]> {
    const response = await this.client.get<Release[]>(`/repos/${owner}/${repo}/releases`, {
      params,
    });
    return response.data;
  }

  async getRelease(owner: string, repo: string, releaseId: number): Promise<Release> {
    const response = await this.client.get<Release>(
      `/repos/${owner}/${repo}/releases/${releaseId}`
    );
    return response.data;
  }

  async getLatestRelease(owner: string, repo: string): Promise<Release> {
    const response = await this.client.get<Release>(`/repos/${owner}/${repo}/releases/latest`);
    return response.data;
  }

  async createRelease(
    owner: string,
    repo: string,
    params: {
      tag_name: string;
      name?: string;
      body?: string;
      draft?: boolean;
      prerelease?: boolean;
      target_commitish?: string;
    }
  ): Promise<Release> {
    const response = await this.client.post<Release>(`/repos/${owner}/${repo}/releases`, params);
    return response.data;
  }

async function handleToolCall(name: string, args: ToolArgs): Promise<unknown> {
  logger.info(`Handling tool call: ${name}`, { args });

  try {
    switch (name) {
      // Repository operations
      case 'github_list_repos':
        return await github.listRepos({
          type: args.type as 'all' | 'owner' | 'public' | 'private' | 'member',
          sort: args.sort as 'created' | 'updated' | 'pushed' | 'full_name',
          per_page: args.per_page as number,
          page: args.page as number,
        });

      case 'github_list_org_repos':
        return await github.listOrgRepos(args.org as string, {
          type: args.type as 'all' | 'public' | 'private' | 'forks' | 'sources' | 'member',
          sort: args.sort as 'created' | 'updated' | 'pushed' | 'full_name',
          per_page: args.per_page as number,
          page: args.page as number,
        });

      case 'github_get_repo':
        return await github.getRepo(args.owner as string, args.repo as string);

      

async function main(): Promise<void> {
  const server = new Server(
    {
      name: 'github-mcp-server',
      version: '1.0.0',
    },
    {
      capabilities: {
        tools: {},
      },
    }
  );

  // Register tool list handler
  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return { tools };
  });

  // Register tool call handler
  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;

    try {
      const result = await handleToolCall(name, args as ToolArgs);
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(result, null, 2),
          },
        ],
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      return {
        content: [
          {
            type: 'text',
            text: `Error: ${errorMessage}`,
          },
        ],
        isError: true,
      };

export function generateBearerAuth(token: string): string {
  return `Bearer ${token}`;
}

export function generateTokenAuth(token: string): string {
  return `token ${token}`;
}

function getRequiredEnv(key: string): string {
  const value = process.env[key];
  if (!value) {
    throw new Error(`Missing required environment variable: ${key}`);
  }
  return value;
}

function getOptionalEnv(key: string, defaultValue: string): string {
  return process.env[key] || defaultValue;
}

export function loadConfig(): Config {
  const token = getRequiredEnv('GITHUB_TOKEN');
  const apiUrl = getOptionalEnv('GITHUB_API_URL', 'https://api.github.com');
  const logLevel = getOptionalEnv('LOG_LEVEL', 'info');

  return {
    github: {
      token,
      apiUrl,
      logLevel,
    },
    logLevel,
  };
}

class Logger {
  private level: LogLevel;

  constructor(level: string = 'info') {
    this.level = this.parseLevel(level);
  }

  private parseLevel(level: string): LogLevel {
    const normalized = level.toLowerCase();
    if (normalized in LOG_LEVELS) {
      return normalized as LogLevel;
    }
    return 'info';
  }

  private shouldLog(level: LogLevel): boolean {
    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
  }

  private formatMessage(level: LogLevel, message: string, meta?: object): string {
    const timestamp = new Date().toISOString();
    const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
    return `[${timestamp}] [${level.toUpperCase()}] ${message}${metaStr}`;
  }

  debug(message: string, meta?: object): void {
    if (this.shouldLog('debug')) {
      console.debug(this.formatMessage('debug', message, meta));
    }
  }

  info(message: string, meta?: object): void {
    if (this.shouldLog('info')) {
      console.info(this.formatMessage('info', message, m

  constructor(level: string = 'info') {
    this.level = this.parseLevel(level);
  }

  private parseLevel(level: string): LogLevel {
    const normalized = level.toLowerCase();
    if (normalized in LOG_LEVELS) {
      return normalized as LogLevel;
    }
    return 'info';
  }

  private shouldLog(level: LogLevel): boolean {
    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
  }

  private formatMessage(level: LogLevel, message: string, meta?: object): string {
    const timestamp = new Date().toISOString();
    const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
    return `[${timestamp}] [${level.toUpperCase()}] ${message}${metaStr}`;
  }

  debug(message: string, meta?: object): void {
    if (this.shouldLog('debug')) {
      console.debug(this.formatMessage('debug', message, meta));
    }
  }

  info(message: string, meta?: object): void {
    if (this.shouldLog('info')) {
      console.info(this.formatMessage('info', message, meta));
    }
  }

  warn(message: string, meta?: object): void {
    if (this.shouldLog('warn')) {
      console.warn(this.formatMessage('warn', message, meta));
    }
  }

  error(message: string, meta?: object): void {
    if (this.shouldLog('error')) {
      console.error(this.formatMessage('error', message, meta));
    }
  }

  setLevel(level: string): void {
    this.level = this.parseLevel(level);
  }

  constructor(config: GitLabConfig) {
    this.client = axios.create({
      baseURL: config.apiUrl,
      headers: {
        'PRIVATE-TOKEN': generatePrivateTokenAuth(config.token),
        'Content-Type': 'application/json',
      },
    });

    // Request interceptor for logging
    this.client.interceptors.request.use((request) => {
      logger.debug('GitLab API Request', {
        method: request.method,
        url: request.url,
      });
      return request;
    });

    // Response interceptor for error handling
    this.client.interceptors.response.use(
      (response) => response,
      (error: AxiosError) => {
        const status = error.response?.status;
        const message = (error.response?.data as { message?: string })?.message || error.message;

        logger.error('GitLab API Error', {
          status,
          message,
          url: error.config?.url,
        });

        throw error;
      }
    );
  }

  private encodeProjectId(projectId: string | number): string {
    if (typeof projectId === 'number') {
      return String(projectId);
    }
    return encodeURIComponent(projectId);
  }

  async listProjects(
    params: {
      membership?: boolean;
      owned?: boolean;
      visibility?: 'public' | 'internal' | 'private';
      order_by?: 'id' | 'name' | 'path' | 'created_at' | 'updated_at' | 'last_activity_at';
      sort?: 'asc' | 'desc';
      per_page?: number;
      page?: number;
    } = {}
  ): Promise<Project[]> {
    const response = await this.client.get<Project[]>('/projects', { params });
    return response.data;
  }