opencode-gitlab-plugin 2.0.0

package/dist/index.js

@@ -0,0 +1,4745 @@
+// src/tools/merge-requests.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/utils.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// src/client/base.ts
+var GitLabApiClient = class {
+  instanceUrl;
+  token;
+  constructor(instanceUrl, token) {
+    this.instanceUrl = instanceUrl.replace(/\/$/, "");
+    this.token = token;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  encodeProjectId(projectId) {
+    if (projectId.includes("/")) {
+      return encodeURIComponent(projectId);
+    }
+    return projectId;
+  }
+  async fetch(method, path2, body) {
+    const url = `${this.instanceUrl}/api/v4${path2}`;
+    const response = await fetch(url, {
+      method,
+      headers: this.headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`GitLab API error ${response.status}: ${errorText}`);
+    }
+    const text = await response.text();
+    if (!text) {
+      return {};
+    }
+    return JSON.parse(text);
+  }
+  async fetchText(method, path2) {
+    const url = `${this.instanceUrl}/api/v4${path2}`;
+    const response = await fetch(url, {
+      method,
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`GitLab API error ${response.status}: ${errorText}`);
+    }
+    return response.text();
+  }
+  /**
+   * Execute a GraphQL query or mutation
+   * @template T - The expected type of the data field in the GraphQL response
+   * @param query - The GraphQL query or mutation string
+   * @param variables - Optional variables for the query
+   * @returns The data from the GraphQL response
+   */
+  async fetchGraphQL(query, variables) {
+    const url = `${this.instanceUrl}/api/graphql`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ query, variables })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`GitLab GraphQL error ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    if (result.errors && result.errors.length > 0) {
+      const errorMessages = result.errors.map((e) => e.message).join(", ");
+      throw new Error(`GraphQL errors: ${errorMessages}`);
+    }
+    return result.data;
+  }
+};
+
+// src/client/notes-types.ts
+function buildPaginationVariables(options) {
+  const variables = {};
+  if (options?.first !== void 0) {
+    variables.first = options.first;
+  } else if (options?.last == null) {
+    variables.first = 20;
+  }
+  if (options?.after) variables.after = options.after;
+  if (options?.last !== void 0) variables.last = options.last;
+  if (options?.before) variables.before = options.before;
+  return variables;
+}
+var NOTES_FRAGMENT = `
+  fragment NoteFields on Note {
+    id
+    body
+    bodyHtml
+    createdAt
+    updatedAt
+    system
+    internal
+    resolvable
+    resolved
+    resolvedAt
+    url
+    author {
+      id
+      username
+      name
+      avatarUrl
+    }
+  }
+`;
+var NOTES_CONNECTION_FRAGMENT = `
+  fragment NotesConnectionFields on NoteConnection {
+    count
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+    nodes {
+      ...NoteFields
+    }
+  }
+`;
+
+// src/client/discussions-types.ts
+function buildDiscussionsPaginationVariables(options) {
+  const variables = {};
+  if (options?.first !== void 0) {
+    variables.first = options.first;
+  } else if (options?.last == null) {
+    variables.first = 20;
+  }
+  if (options?.after) variables.after = options.after;
+  if (options?.last !== void 0) variables.last = options.last;
+  if (options?.before) variables.before = options.before;
+  return variables;
+}
+var DISCUSSION_NOTE_FRAGMENT = `
+  fragment DiscussionNoteFields on Note {
+    id
+    body
+    bodyHtml
+    createdAt
+    updatedAt
+    system
+    resolvable
+    resolved
+    resolvedAt
+    url
+    author {
+      id
+      username
+      name
+      avatarUrl
+    }
+  }
+`;
+var DISCUSSION_FRAGMENT = `
+  fragment DiscussionFields on Discussion {
+    id
+    replyId
+    createdAt
+    resolved
+    resolvable
+    resolvedAt
+    resolvedBy {
+      id
+      username
+      name
+      avatarUrl
+    }
+    notes {
+      nodes {
+        ...DiscussionNoteFields
+      }
+    }
+  }
+`;
+var DISCUSSIONS_CONNECTION_FRAGMENT = `
+  fragment DiscussionsConnectionFields on DiscussionConnection {
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+    nodes {
+      ...DiscussionFields
+    }
+  }
+`;
+
+// src/client/merge-requests.ts
+var LIST_MR_NOTES_QUERY = `
+  ${NOTES_FRAGMENT}
+  ${NOTES_CONNECTION_FRAGMENT}
+  query listMrNotes(
+    $projectPath: ID!
+    $mrIid: String!
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    project(fullPath: $projectPath) {
+      mergeRequest(iid: $mrIid) {
+        notes(
+          first: $first
+          after: $after
+          last: $last
+          before: $before
+        ) {
+          ...NotesConnectionFields
+        }
+      }
+    }
+  }
+`;
+var LIST_MR_DISCUSSIONS_QUERY = `
+  ${DISCUSSION_NOTE_FRAGMENT}
+  ${DISCUSSION_FRAGMENT}
+  ${DISCUSSIONS_CONNECTION_FRAGMENT}
+  query listMrDiscussions(
+    $projectPath: ID!
+    $mrIid: String!
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    project(fullPath: $projectPath) {
+      mergeRequest(iid: $mrIid) {
+        discussions(
+          first: $first
+          after: $after
+          last: $last
+          before: $before
+        ) {
+          ...DiscussionsConnectionFields
+        }
+      }
+    }
+  }
+`;
+var SET_AUTO_MERGE_MUTATION = `
+  mutation setAutoMerge(
+    $projectPath: ID!
+    $iid: String!
+    $sha: String!
+    $strategy: MergeStrategyEnum
+  ) {
+    mergeRequestAccept(
+      input: {
+        projectPath: $projectPath
+        iid: $iid
+        sha: $sha
+        strategy: $strategy
+      }
+    ) {
+      mergeRequest {
+        id
+        iid
+        title
+        autoMergeEnabled
+        autoMergeStrategy
+      }
+      errors
+    }
+  }
+`;
+var RESOLVE_DISCUSSION_MUTATION = `
+  mutation resolveDiscussion($discussionId: DiscussionID!, $resolve: Boolean!) {
+    discussionToggleResolve(input: { id: $discussionId, resolve: $resolve }) {
+      discussion {
+        id
+        resolved
+        resolvedAt
+        resolvedBy {
+          id
+          username
+          name
+        }
+      }
+      errors
+    }
+  }
+`;
+var MergeRequestsClient = class extends GitLabApiClient {
+  async getMergeRequest(projectId, mrIid, includeChanges) {
+    const encodedProject = this.encodeProjectId(projectId);
+    let path2 = `/projects/${encodedProject}/merge_requests/${mrIid}`;
+    if (includeChanges) {
+      path2 += "?include_diverged_commits_count=true";
+    }
+    return this.fetch("GET", path2);
+  }
+  async listMergeRequests(options) {
+    const params = new URLSearchParams();
+    params.set("per_page", String(options.limit || 20));
+    if (options.state) params.set("state", options.state);
+    if (options.scope) params.set("scope", options.scope);
+    if (options.search) params.set("search", options.search);
+    if (options.labels) params.set("labels", options.labels);
+    let path2;
+    if (options.projectId) {
+      const encodedProject = this.encodeProjectId(options.projectId);
+      path2 = `/projects/${encodedProject}/merge_requests?${params}`;
+    } else {
+      path2 = `/merge_requests?${params}`;
+    }
+    return this.fetch("GET", path2);
+  }
+  async getMrChanges(projectId, mrIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/changes`
+    );
+  }
+  /**
+   * List notes on a merge request using GraphQL API with pagination support
+   */
+  async listMrNotes(projectId, mrIid, options) {
+    const variables = {
+      projectPath: projectId,
+      mrIid: String(mrIid),
+      ...buildPaginationVariables(options)
+    };
+    const result = await this.fetchGraphQL(LIST_MR_NOTES_QUERY, variables);
+    const notes = result.project?.mergeRequest?.notes;
+    if (!notes) {
+      throw new Error("Merge request not found or access denied");
+    }
+    return {
+      notes,
+      pageInfo: notes.pageInfo,
+      totalCount: notes.count
+    };
+  }
+  /**
+   * List discussions on a merge request using GraphQL API with pagination support
+   */
+  async listMrDiscussions(projectId, mrIid, options) {
+    const variables = {
+      projectPath: projectId,
+      mrIid: String(mrIid),
+      ...buildDiscussionsPaginationVariables(options)
+    };
+    const result = await this.fetchGraphQL(LIST_MR_DISCUSSIONS_QUERY, variables);
+    const discussions = result.project?.mergeRequest?.discussions;
+    if (!discussions) {
+      throw new Error("Merge request not found or access denied");
+    }
+    return { discussions };
+  }
+  async getMrDiscussion(projectId, mrIid, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/discussions/${discussionId}`
+    );
+  }
+  async resolveMrDiscussion(projectId, mrIid, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "PUT",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/discussions/${discussionId}`,
+      { resolved: true }
+    );
+  }
+  async unresolveMrDiscussion(projectId, mrIid, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "PUT",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/discussions/${discussionId}`,
+      { resolved: false }
+    );
+  }
+  /**
+   * Resolve or unresolve a discussion using GraphQL API.
+   * This works for all discussions including outdated ones (resolved: null)
+   * which the REST API cannot handle.
+   *
+   * @param discussionId - The discussion ID (can be short ID or full gid://gitlab/Discussion/ID format)
+   * @param resolve - Whether to resolve (true) or unresolve (false) the discussion
+   */
+  async toggleDiscussionResolved(discussionId, resolve2) {
+    const gid = discussionId.startsWith("gid://") ? discussionId : `gid://gitlab/Discussion/${discussionId}`;
+    const result = await this.fetchGraphQL(RESOLVE_DISCUSSION_MUTATION, {
+      discussionId: gid,
+      resolve: resolve2
+    });
+    if (result.discussionToggleResolve.errors.length > 0) {
+      throw new Error(
+        `Failed to ${resolve2 ? "resolve" : "unresolve"} discussion: ${result.discussionToggleResolve.errors.join(", ")}`
+      );
+    }
+    if (!result.discussionToggleResolve.discussion) {
+      throw new Error(
+        `Failed to ${resolve2 ? "resolve" : "unresolve"} discussion: No discussion returned`
+      );
+    }
+    return result.discussionToggleResolve.discussion;
+  }
+  async createMrDiscussion(projectId, mrIid, body, position) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const requestBody = { body };
+    if (position) {
+      requestBody.position = position;
+    }
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/discussions`,
+      requestBody
+    );
+  }
+  async createMrNote(projectId, mrIid, body, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    if (discussionId) {
+      return this.fetch(
+        "POST",
+        `/projects/${encodedProject}/merge_requests/${mrIid}/discussions/${discussionId}/notes`,
+        { body }
+      );
+    }
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/notes`,
+      { body }
+    );
+  }
+  async createMergeRequest(projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/merge_requests`,
+      options
+    );
+  }
+  async updateMergeRequest(projectId, mrIid, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "PUT",
+      `/projects/${encodedProject}/merge_requests/${mrIid}`,
+      options
+    );
+  }
+  async getMrCommits(projectId, mrIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/commits`
+    );
+  }
+  async getMrPipelines(projectId, mrIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/pipelines`
+    );
+  }
+  /**
+   * Add a reviewer to a merge request without affecting existing reviewers
+   */
+  async addReviewer(projectId, mrIid, reviewerId) {
+    const mr = await this.getMergeRequest(projectId, mrIid);
+    const currentReviewers = mr.reviewers || [];
+    const currentReviewerIds = currentReviewers.map((r) => r.id);
+    if (currentReviewerIds.includes(reviewerId)) {
+      return mr;
+    }
+    const newReviewerIds = [...currentReviewerIds, reviewerId];
+    return this.updateMergeRequest(projectId, mrIid, { reviewer_ids: newReviewerIds });
+  }
+  /**
+   * Remove a reviewer from a merge request without affecting other reviewers
+   */
+  async removeReviewer(projectId, mrIid, reviewerId) {
+    const mr = await this.getMergeRequest(projectId, mrIid);
+    const currentReviewers = mr.reviewers || [];
+    const currentReviewerIds = currentReviewers.map((r) => r.id);
+    if (!currentReviewerIds.includes(reviewerId)) {
+      return mr;
+    }
+    const newReviewerIds = currentReviewerIds.filter((id) => id !== reviewerId);
+    return this.updateMergeRequest(projectId, mrIid, { reviewer_ids: newReviewerIds });
+  }
+  async listMergeRequestDiffs(projectId, mrIid, options = {}) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    if (options.page) params.append("page", options.page.toString());
+    if (options.per_page) params.append("per_page", options.per_page.toString());
+    const query = params.toString();
+    const path2 = `/projects/${encodedProject}/merge_requests/${mrIid}/diffs${query ? `?${query}` : ""}`;
+    return this.fetch("GET", path2);
+  }
+  /**
+   * Set auto-merge (MWPS) on a merge request using GraphQL API
+   * Uses the mergeRequestAccept mutation with a merge strategy
+   */
+  async setAutoMerge(projectId, mrIid, sha, strategy = "MERGE_WHEN_CHECKS_PASS") {
+    const result = await this.fetchGraphQL(SET_AUTO_MERGE_MUTATION, {
+      projectPath: projectId,
+      iid: String(mrIid),
+      sha,
+      strategy
+    });
+    if (result.mergeRequestAccept.errors.length > 0) {
+      throw new Error(`Failed to set auto-merge: ${result.mergeRequestAccept.errors.join(", ")}`);
+    }
+    if (!result.mergeRequestAccept.mergeRequest) {
+      throw new Error("Failed to set auto-merge: No merge request returned");
+    }
+    return result.mergeRequestAccept.mergeRequest;
+  }
+  /**
+   * Approve a merge request
+   * Requires at least Developer role on the project
+   */
+  async approveMergeRequest(projectId, mrIid, sha) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/approve`,
+      sha ? { sha } : void 0
+    );
+  }
+  /**
+   * Unapprove (revoke approval from) a merge request
+   * Only removes the current user's approval
+   */
+  async unapproveMergeRequest(projectId, mrIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/unapprove`
+    );
+  }
+};
+
+// src/client/issues.ts
+var LIST_ISSUE_NOTES_QUERY = `
+  ${NOTES_FRAGMENT}
+  ${NOTES_CONNECTION_FRAGMENT}
+  query listIssueNotes(
+    $projectPath: ID!
+    $issueIid: String!
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    project(fullPath: $projectPath) {
+      issue(iid: $issueIid) {
+        notes(
+          first: $first
+          after: $after
+          last: $last
+          before: $before
+        ) {
+          ...NotesConnectionFields
+        }
+      }
+    }
+  }
+`;
+var LIST_ISSUE_DISCUSSIONS_QUERY = `
+  ${DISCUSSION_NOTE_FRAGMENT}
+  ${DISCUSSION_FRAGMENT}
+  ${DISCUSSIONS_CONNECTION_FRAGMENT}
+  query listIssueDiscussions(
+    $projectPath: ID!
+    $issueIid: String!
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    project(fullPath: $projectPath) {
+      issue(iid: $issueIid) {
+        discussions(
+          first: $first
+          after: $after
+          last: $last
+          before: $before
+        ) {
+          ...DiscussionsConnectionFields
+        }
+      }
+    }
+  }
+`;
+var IssuesClient = class extends GitLabApiClient {
+  async createIssue(projectId, title, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const body = {
+      title,
+      ...Object.fromEntries(
+        Object.entries(options || {}).filter(([_, value]) => value !== void 0)
+      )
+    };
+    return this.fetch("POST", `/projects/${encodedProject}/issues`, body);
+  }
+  async getIssue(projectId, issueIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/issues/${issueIid}`
+    );
+  }
+  async listIssues(options) {
+    const params = new URLSearchParams();
+    params.set("per_page", String(options.limit || 20));
+    if (options.state) params.set("state", options.state);
+    if (options.scope) params.set("scope", options.scope);
+    if (options.search) params.set("search", options.search);
+    if (options.labels) params.set("labels", options.labels);
+    if (options.milestone) params.set("milestone", options.milestone);
+    let path2;
+    if (options.projectId) {
+      const encodedProject = this.encodeProjectId(options.projectId);
+      path2 = `/projects/${encodedProject}/issues?${params}`;
+    } else {
+      path2 = `/issues?${params}`;
+    }
+    return this.fetch("GET", path2);
+  }
+  /**
+   * List notes on an issue using GraphQL API with pagination support
+   */
+  async listIssueNotes(projectId, issueIid, options) {
+    const variables = {
+      projectPath: projectId,
+      issueIid: String(issueIid),
+      ...buildPaginationVariables(options)
+    };
+    const result = await this.fetchGraphQL(LIST_ISSUE_NOTES_QUERY, variables);
+    const notes = result.project?.issue?.notes;
+    if (!notes) {
+      throw new Error("Issue not found or access denied");
+    }
+    return {
+      notes,
+      pageInfo: notes.pageInfo,
+      totalCount: notes.count
+    };
+  }
+  /**
+   * List discussions on an issue using GraphQL API with pagination support
+   */
+  async listIssueDiscussions(projectId, issueIid, options) {
+    const variables = {
+      projectPath: projectId,
+      issueIid: String(issueIid),
+      ...buildDiscussionsPaginationVariables(options)
+    };
+    const result = await this.fetchGraphQL(LIST_ISSUE_DISCUSSIONS_QUERY, variables);
+    const discussions = result.project?.issue?.discussions;
+    if (!discussions) {
+      throw new Error("Issue not found or access denied");
+    }
+    return { discussions };
+  }
+  async getIssueDiscussion(projectId, issueIid, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/issues/${issueIid}/discussions/${discussionId}`
+    );
+  }
+  async createIssueNote(projectId, issueIid, body, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    if (discussionId) {
+      return this.fetch(
+        "POST",
+        `/projects/${encodedProject}/issues/${issueIid}/discussions/${discussionId}/notes`,
+        { body }
+      );
+    }
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/issues/${issueIid}/notes`,
+      { body }
+    );
+  }
+  async resolveIssueDiscussion(projectId, issueIid, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "PUT",
+      `/projects/${encodedProject}/issues/${issueIid}/discussions/${discussionId}`,
+      { resolved: true }
+    );
+  }
+  async unresolveIssueDiscussion(projectId, issueIid, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "PUT",
+      `/projects/${encodedProject}/issues/${issueIid}/discussions/${discussionId}`,
+      { resolved: false }
+    );
+  }
+  async getIssueNote(projectId, issueIid, noteId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/issues/${issueIid}/notes/${noteId}`
+    );
+  }
+};
+
+// src/client/work-items.ts
+var WorkItemsClient = class extends GitLabApiClient {
+  async getWorkItem(projectId, workItemId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/work_items/${workItemId}`
+    );
+  }
+  async listWorkItems(options) {
+    const params = new URLSearchParams();
+    params.set("per_page", String(options.limit || 20));
+    if (options.state) params.set("state", options.state);
+    if (options.search) params.set("search", options.search);
+    if (options.labels) params.set("labels", options.labels);
+    if (options.work_item_type) params.set("type", options.work_item_type);
+    let path2;
+    if (options.projectId) {
+      const encodedProject = this.encodeProjectId(options.projectId);
+      path2 = `/projects/${encodedProject}/work_items?${params}`;
+    } else if (options.groupId) {
+      const encodedGroup = encodeURIComponent(options.groupId);
+      path2 = `/groups/${encodedGroup}/work_items?${params}`;
+    } else {
+      throw new Error("Either projectId or groupId must be provided");
+    }
+    return this.fetch("GET", path2);
+  }
+  async getWorkItemNotes(projectId, workItemId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/work_items/${workItemId}/notes`
+    );
+  }
+  async createWorkItem(projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/work_items`,
+      options
+    );
+  }
+  async updateWorkItem(projectId, workItemId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "PUT",
+      `/projects/${encodedProject}/work_items/${workItemId}`,
+      options
+    );
+  }
+  async createWorkItemNote(projectId, workItemId, body) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/work_items/${workItemId}/notes`,
+      { body }
+    );
+  }
+};
+
+// src/client/pipelines.ts
+var PipelinesClient = class extends GitLabApiClient {
+  async listPipelines(projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.status) params.set("status", options.status);
+    if (options?.ref) params.set("ref", options.ref);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/pipelines?${params}`
+    );
+  }
+  async getPipeline(projectId, pipelineId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/pipelines/${pipelineId}`
+    );
+  }
+  async listPipelineJobs(projectId, pipelineId, scope) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    if (scope) params.set("scope[]", scope);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/pipelines/${pipelineId}/jobs?${params}`
+    );
+  }
+  async getJobLog(projectId, jobId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const log = await this.fetchText("GET", `/projects/${encodedProject}/jobs/${jobId}/trace`);
+    const maxLength = 5e4;
+    if (log.length > maxLength) {
+      return `[Log truncated, showing last ${maxLength} characters]
+
+${log.slice(-maxLength)}`;
+    }
+    return log;
+  }
+  async retryJob(projectId, jobId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/jobs/${jobId}/retry`
+    );
+  }
+  async getPipelineFailingJobs(projectId, pipelineId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const jobs = await this.fetch(
+      "GET",
+      `/projects/${encodedProject}/pipelines/${pipelineId}/jobs?scope[]=failed`
+    );
+    return jobs;
+  }
+  /**
+   * Validate a CI/CD configuration
+   * @param projectId - The project ID or URL-encoded path
+   * @param content - The CI/CD configuration content (YAML as string)
+   * @param options - Optional parameters
+   * @param options.dry_run - Run pipeline creation simulation (default: false)
+   * @param options.include_jobs - Include list of jobs in response (default: false)
+   * @param options.ref - Branch or tag context for validation (defaults to project's default branch)
+   * @returns Validation result with errors, warnings, and optionally merged YAML and jobs
+   */
+  async lintCiConfig(projectId, content, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const body = {
+      content
+    };
+    if (options?.dry_run !== void 0) body.dry_run = options.dry_run;
+    if (options?.include_jobs !== void 0) body.include_jobs = options.include_jobs;
+    if (options?.ref) body.ref = options.ref;
+    return this.fetch("POST", `/projects/${encodedProject}/ci/lint`, body);
+  }
+  /**
+   * Validate an existing CI/CD configuration from the repository
+   * @param projectId - The project ID or URL-encoded path
+   * @param options - Optional parameters
+   * @param options.content_ref - Commit SHA, branch or tag to get CI config from (defaults to default branch)
+   * @param options.dry_run - Run pipeline creation simulation (default: false)
+   * @param options.dry_run_ref - Branch or tag context for validation (defaults to project's default branch)
+   * @param options.include_jobs - Include list of jobs in response (default: false)
+   * @returns Validation result with errors, warnings, and optionally merged YAML and jobs
+   */
+  async lintExistingCiConfig(projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    if (options?.content_ref) params.set("content_ref", options.content_ref);
+    if (options?.dry_run !== void 0) params.set("dry_run", String(options.dry_run));
+    if (options?.dry_run_ref) params.set("dry_run_ref", options.dry_run_ref);
+    if (options?.include_jobs !== void 0)
+      params.set("include_jobs", String(options.include_jobs));
+    const queryString = params.toString();
+    const path2 = queryString ? `/projects/${encodedProject}/ci/lint?${queryString}` : `/projects/${encodedProject}/ci/lint`;
+    return this.fetch("GET", path2);
+  }
+};
+
+// src/client/repository.ts
+var RepositoryClient = class extends GitLabApiClient {
+  async getFile(projectId, filePath, ref) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const encodedPath = encodeURIComponent(filePath);
+    let url = `/projects/${encodedProject}/repository/files/${encodedPath}`;
+    if (ref) {
+      url += `?ref=${encodeURIComponent(ref)}`;
+    }
+    const file = await this.fetch("GET", url);
+    if (file.encoding === "base64") {
+      return Buffer.from(file.content, "base64").toString("utf-8");
+    }
+    return file.content;
+  }
+  async listCommits(projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.ref) params.set("ref_name", options.ref);
+    if (options?.path) params.set("path", options.path);
+    if (options?.since) params.set("since", options.since);
+    if (options?.until) params.set("until", options.until);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/repository/commits?${params}`
+    );
+  }
+  async getCommit(projectId, sha) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/repository/commits/${sha}`
+    );
+  }
+  async getCommitDiff(projectId, sha) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/repository/commits/${sha}/diff`
+    );
+  }
+  async createCommit(projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/repository/commits`,
+      options
+    );
+  }
+  async listRepositoryTree(projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    if (options?.path) params.set("path", options.path);
+    if (options?.ref) params.set("ref", options.ref);
+    if (options?.recursive) params.set("recursive", "true");
+    if (options?.per_page) params.set("per_page", String(options.per_page));
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/repository/tree?${params}`
+    );
+  }
+  async listBranches(projectId, search) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    if (search) params.set("search", search);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/repository/branches?${params}`
+    );
+  }
+  // ========== Commit Discussion Methods ==========
+  async listCommitDiscussions(projectId, sha) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/repository/commits/${sha}/discussions`
+    );
+  }
+  async getCommitDiscussion(projectId, sha, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/repository/commits/${sha}/discussions/${discussionId}`
+    );
+  }
+  async createCommitNote(projectId, sha, body, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    if (options?.discussion_id) {
+      return this.fetch(
+        "POST",
+        `/projects/${encodedProject}/repository/commits/${sha}/discussions/${options.discussion_id}/notes`,
+        { body }
+      );
+    }
+    const requestBody = { body };
+    if (options?.path) requestBody.path = options.path;
+    if (options?.line) requestBody.line = options.line;
+    if (options?.line_type) requestBody.line_type = options.line_type;
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/repository/commits/${sha}/comments`,
+      requestBody
+    );
+  }
+  async createCommitDiscussion(projectId, sha, body, position) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const requestBody = { body };
+    if (position) {
+      requestBody.position = position;
+    }
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/repository/commits/${sha}/discussions`,
+      requestBody
+    );
+  }
+  /**
+   * Get comments on a specific commit
+   * API: GET /projects/:id/repository/commits/:sha/comments
+   */
+  async getCommitComments(projectId, sha) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/repository/commits/${sha}/comments`
+    );
+  }
+};
+
+// src/client/search.ts
+var SearchClient = class extends GitLabApiClient {
+  async search(scope, searchQuery, projectId, limit) {
+    const params = new URLSearchParams();
+    params.set("scope", scope);
+    params.set("search", searchQuery);
+    params.set("per_page", String(limit || 20));
+    let path2;
+    if (projectId) {
+      const encodedProject = this.encodeProjectId(projectId);
+      path2 = `/projects/${encodedProject}/search?${params}`;
+    } else {
+      path2 = `/search?${params}`;
+    }
+    return this.fetch("GET", path2);
+  }
+  /**
+   * Search for commits in a project or globally
+   * @param searchQuery - The search term
+   * @param projectId - Optional project ID to limit search
+   * @param options - Optional search parameters
+   */
+  async searchCommits(searchQuery, projectId, options) {
+    const params = new URLSearchParams();
+    params.set("scope", "commits");
+    params.set("search", searchQuery);
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.ref) params.set("ref", options.ref);
+    if (options?.order_by) params.set("order_by", options.order_by);
+    if (options?.sort) params.set("sort", options.sort);
+    let path2;
+    if (projectId) {
+      const encodedProject = this.encodeProjectId(projectId);
+      path2 = `/projects/${encodedProject}/search?${params}`;
+    } else {
+      path2 = `/search?${params}`;
+    }
+    return this.fetch("GET", path2);
+  }
+  /**
+   * Search for projects within a specific group
+   * @param groupId - The group ID or URL-encoded path
+   * @param searchQuery - The search term
+   * @param options - Optional search parameters
+   */
+  async searchGroupProjects(groupId, searchQuery, options) {
+    const encodedGroup = this.encodeProjectId(groupId);
+    const params = new URLSearchParams();
+    params.set("scope", "projects");
+    params.set("search", searchQuery);
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.order_by) params.set("order_by", options.order_by);
+    if (options?.sort) params.set("sort", options.sort);
+    return this.fetch("GET", `/groups/${encodedGroup}/search?${params}`);
+  }
+  /**
+   * Search for milestones in a project or globally
+   * @param searchQuery - The search term
+   * @param projectId - Optional project ID to limit search
+   * @param options - Optional search parameters
+   */
+  async searchMilestones(searchQuery, projectId, options) {
+    const params = new URLSearchParams();
+    params.set("scope", "milestones");
+    params.set("search", searchQuery);
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.state) params.set("state", options.state);
+    if (options?.order_by) params.set("order_by", options.order_by);
+    if (options?.sort) params.set("sort", options.sort);
+    let path2;
+    if (projectId) {
+      const encodedProject = this.encodeProjectId(projectId);
+      path2 = `/projects/${encodedProject}/search?${params}`;
+    } else {
+      path2 = `/search?${params}`;
+    }
+    return this.fetch("GET", path2);
+  }
+  /**
+   * Search for notes/comments in a project
+   * @param searchQuery - The search term
+   * @param projectId - The project ID to search in
+   * @param options - Optional search parameters
+   */
+  async searchNotes(searchQuery, projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    params.set("scope", "notes");
+    params.set("search", searchQuery);
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.order_by) params.set("order_by", options.order_by);
+    if (options?.sort) params.set("sort", options.sort);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/search?${params}`
+    );
+  }
+  /**
+   * Search for users by name or email
+   * @param searchQuery - The search term (name or email)
+   * @param projectId - Optional project ID to limit search
+   * @param options - Optional search parameters
+   */
+  async searchUsers(searchQuery, projectId, options) {
+    const params = new URLSearchParams();
+    params.set("scope", "users");
+    params.set("search", searchQuery);
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.order_by) params.set("order_by", options.order_by);
+    if (options?.sort) params.set("sort", options.sort);
+    let path2;
+    if (projectId) {
+      const encodedProject = this.encodeProjectId(projectId);
+      path2 = `/projects/${encodedProject}/search?${params}`;
+    } else {
+      path2 = `/search?${params}`;
+    }
+    return this.fetch("GET", path2);
+  }
+  /**
+   * Search for wiki blobs (wiki content)
+   * @param searchQuery - The search term (supports filters like filename:, path:, extension:)
+   * @param projectId - Optional project ID to limit search
+   * @param options - Optional search parameters
+   */
+  async searchWikiBlobs(searchQuery, projectId, options) {
+    const params = new URLSearchParams();
+    params.set("scope", "wiki_blobs");
+    params.set("search", searchQuery);
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.ref) params.set("ref", options.ref);
+    if (options?.order_by) params.set("order_by", options.order_by);
+    if (options?.sort) params.set("sort", options.sort);
+    let path2;
+    if (projectId) {
+      const encodedProject = this.encodeProjectId(projectId);
+      path2 = `/projects/${encodedProject}/search?${params}`;
+    } else {
+      path2 = `/search?${params}`;
+    }
+    return this.fetch("GET", path2);
+  }
+  /**
+   * Search GitLab documentation
+   * Note: This uses the public GitLab docs search API
+   * @param searchQuery - The search term
+   * @param limit - Maximum number of results (default: 10)
+   */
+  async searchDocumentation(searchQuery, limit) {
+    const url = `https://docs.gitlab.com/search.json?q=${encodeURIComponent(searchQuery)}&limit=${limit || 10}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Documentation search error ${response.status}: ${await response.text()}`);
+    }
+    return response.json();
+  }
+};
+
+// src/client/projects.ts
+var ProjectsClient = class extends GitLabApiClient {
+  async getProject(projectId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch("GET", `/projects/${encodedProject}`);
+  }
+  async listProjectMembers(projectId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch("GET", `/projects/${encodedProject}/members`);
+  }
+};
+
+// src/client/users.ts
+var UsersClient = class extends GitLabApiClient {
+  async getCurrentUser() {
+    return this.fetch("GET", "/user");
+  }
+  /**
+   * Get a user by ID
+   * @param userId - The user ID
+   */
+  async getUser(userId) {
+    return this.fetch("GET", `/users/${userId}`);
+  }
+  /**
+   * Find users by username
+   * @param username - The username to search for (exact match)
+   */
+  async getUserByUsername(username) {
+    const params = new URLSearchParams();
+    params.set("username", username);
+    return this.fetch("GET", `/users?${params}`);
+  }
+  /**
+   * Get a user's status
+   * @param userId - The user ID
+   */
+  async getUserStatus(userId) {
+    return this.fetch("GET", `/users/${userId}/status`);
+  }
+};
+
+// src/client/wikis.ts
+var WikisClient = class extends GitLabApiClient {
+  async getWikiPage(projectId, slug) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const encodedSlug = encodeURIComponent(slug);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/wikis/${encodedSlug}`
+    );
+  }
+};
+
+// src/validation.ts
+function isValidGid(gid, expectedType) {
+  const gidPattern = /^gid:\/\/gitlab\/([A-Za-z]+)\/(\d+)$/;
+  const match = gid.match(gidPattern);
+  if (!match) {
+    return false;
+  }
+  if (expectedType && match[1] !== expectedType) {
+    return false;
+  }
+  return true;
+}
+function validateGid(gid, expectedType) {
+  if (!isValidGid(gid, expectedType)) {
+    const typeMsg = expectedType ? ` of type '${expectedType}'` : "";
+    throw new Error(
+      `Invalid GitLab Global ID${typeMsg}: '${gid}'. Expected format: gid://gitlab/${expectedType || "ResourceType"}/{id}`
+    );
+  }
+}
+
+// src/client/security.ts
+var CREATE_VULNERABILITY_ISSUE_MUTATION = `
+  mutation($projectPath: ID!, $vulnerabilityIds: [VulnerabilityID!]!) {
+    createVulnerabilityIssueLink(input: {
+      projectPath: $projectPath
+      vulnerabilityIds: $vulnerabilityIds
+    }) {
+      issue {
+        id
+        iid
+        title
+        webUrl
+      }
+      errors
+    }
+  }
+`;
+var DISMISS_VULNERABILITY_MUTATION = `
+  mutation($id: VulnerabilityID!, $reason: VulnerabilityDismissalReason!, $comment: String) {
+    vulnerabilityDismiss(input: {
+      id: $id
+      dismissalReason: $reason
+      comment: $comment
+    }) {
+      vulnerability {
+        id
+        state
+        dismissalReason
+      }
+      errors
+    }
+  }
+`;
+var CONFIRM_VULNERABILITY_MUTATION = `
+  mutation($id: VulnerabilityID!, $comment: String) {
+    vulnerabilityConfirm(input: {
+      id: $id
+      comment: $comment
+    }) {
+      vulnerability {
+        id
+        state
+      }
+      errors
+    }
+  }
+`;
+var REVERT_VULNERABILITY_MUTATION = `
+  mutation($id: VulnerabilityID!, $comment: String) {
+    vulnerabilityRevertToDetected(input: {
+      id: $id
+      comment: $comment
+    }) {
+      vulnerability {
+        id
+        state
+      }
+      errors
+    }
+  }
+`;
+var UPDATE_VULNERABILITY_SEVERITY_MUTATION = `
+  mutation($ids: [VulnerabilityID!]!, $severity: VulnerabilitySeverity!, $comment: String!) {
+    vulnerabilitiesUpdateSeverity(input: {
+      ids: $ids
+      severity: $severity
+      comment: $comment
+    }) {
+      vulnerabilities {
+        id
+        severity
+      }
+      errors
+    }
+  }
+`;
+var LINK_VULNERABILITY_TO_ISSUE_MUTATION = `
+  mutation($issueId: IssueID!, $vulnerabilityIds: [VulnerabilityID!]!) {
+    vulnerabilityIssueLinksCreate(input: {
+      issueId: $issueId
+      vulnerabilityIds: $vulnerabilityIds
+    }) {
+      issue {
+        id
+        iid
+        title
+        webUrl
+      }
+      errors
+    }
+  }
+`;
+var SecurityClient = class extends GitLabApiClient {
+  async listVulnerabilities(projectId, options) {
+    const encodedProject = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.state) params.set("state", options.state);
+    if (options?.severity) params.set("severity", options.severity);
+    if (options?.report_type) params.set("report_type", options.report_type);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/vulnerabilities?${params}`
+    );
+  }
+  async getVulnerabilityDetails(projectId, vulnerabilityId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/vulnerabilities/${vulnerabilityId}`
+    );
+  }
+  /**
+   * Create an issue linked to one or more vulnerabilities
+   * @param projectPath - Full path of the project (e.g., 'group/project')
+   * @param vulnerabilityIds - Array of vulnerability IDs in format 'gid://gitlab/Vulnerability/{id}'
+   * @returns The created issue
+   */
+  async createVulnerabilityIssue(projectPath, vulnerabilityIds) {
+    vulnerabilityIds.forEach((id) => validateGid(id, "Vulnerability"));
+    const result = await this.fetchGraphQL(CREATE_VULNERABILITY_ISSUE_MUTATION, { projectPath, vulnerabilityIds });
+    if (result.createVulnerabilityIssueLink.errors.length > 0) {
+      throw new Error(
+        `Failed to create vulnerability issue: ${result.createVulnerabilityIssueLink.errors.join(", ")}`
+      );
+    }
+    return result.createVulnerabilityIssueLink.issue;
+  }
+  /**
+   * Dismiss a vulnerability with a reason
+   * @param vulnerabilityId - Vulnerability ID in format 'gid://gitlab/Vulnerability/{id}'
+   * @param reason - Dismissal reason
+   * @param comment - Optional comment explaining the dismissal
+   * @returns The updated vulnerability
+   */
+  async dismissVulnerability(vulnerabilityId, reason, comment) {
+    validateGid(vulnerabilityId, "Vulnerability");
+    const result = await this.fetchGraphQL(DISMISS_VULNERABILITY_MUTATION, { id: vulnerabilityId, reason, comment });
+    if (result.vulnerabilityDismiss.errors.length > 0) {
+      throw new Error(
+        `Failed to dismiss vulnerability: ${result.vulnerabilityDismiss.errors.join(", ")}`
+      );
+    }
+    return result.vulnerabilityDismiss.vulnerability;
+  }
+  /**
+   * Confirm a vulnerability
+   * @param vulnerabilityId - Vulnerability ID in format 'gid://gitlab/Vulnerability/{id}'
+   * @param comment - Optional comment
+   * @returns The updated vulnerability
+   */
+  async confirmVulnerability(vulnerabilityId, comment) {
+    validateGid(vulnerabilityId, "Vulnerability");
+    const result = await this.fetchGraphQL(CONFIRM_VULNERABILITY_MUTATION, { id: vulnerabilityId, comment });
+    if (result.vulnerabilityConfirm.errors.length > 0) {
+      throw new Error(
+        `Failed to confirm vulnerability: ${result.vulnerabilityConfirm.errors.join(", ")}`
+      );
+    }
+    return result.vulnerabilityConfirm.vulnerability;
+  }
+  /**
+   * Revert a vulnerability back to detected state
+   * @param vulnerabilityId - Vulnerability ID in format 'gid://gitlab/Vulnerability/{id}'
+   * @param comment - Optional comment
+   * @returns The updated vulnerability
+   */
+  async revertVulnerability(vulnerabilityId, comment) {
+    validateGid(vulnerabilityId, "Vulnerability");
+    const result = await this.fetchGraphQL(REVERT_VULNERABILITY_MUTATION, { id: vulnerabilityId, comment });
+    if (result.vulnerabilityRevertToDetected.errors.length > 0) {
+      throw new Error(
+        `Failed to revert vulnerability: ${result.vulnerabilityRevertToDetected.errors.join(", ")}`
+      );
+    }
+    return result.vulnerabilityRevertToDetected.vulnerability;
+  }
+  /**
+   * Update the severity of one or more vulnerabilities
+   * @param vulnerabilityIds - Array of vulnerability IDs in format 'gid://gitlab/Vulnerability/{id}'
+   * @param severity - New severity level
+   * @param comment - Comment explaining the severity change
+   * @returns Array of updated vulnerabilities
+   */
+  async updateVulnerabilitySeverity(vulnerabilityIds, severity, comment) {
+    vulnerabilityIds.forEach((id) => validateGid(id, "Vulnerability"));
+    const result = await this.fetchGraphQL(UPDATE_VULNERABILITY_SEVERITY_MUTATION, { ids: vulnerabilityIds, severity, comment });
+    if (result.vulnerabilitiesUpdateSeverity.errors.length > 0) {
+      throw new Error(
+        `Failed to update vulnerability severity: ${result.vulnerabilitiesUpdateSeverity.errors.join(", ")}`
+      );
+    }
+    return result.vulnerabilitiesUpdateSeverity.vulnerabilities;
+  }
+  /**
+   * Link an existing issue to one or more vulnerabilities
+   * @param issueId - Issue ID in format 'gid://gitlab/Issue/{id}'
+   * @param vulnerabilityIds - Array of vulnerability IDs in format 'gid://gitlab/Vulnerability/{id}'
+   * @returns The linked issue
+   */
+  async linkVulnerabilityToIssue(issueId, vulnerabilityIds) {
+    validateGid(issueId, "Issue");
+    vulnerabilityIds.forEach((id) => validateGid(id, "Vulnerability"));
+    const result = await this.fetchGraphQL(LINK_VULNERABILITY_TO_ISSUE_MUTATION, { issueId, vulnerabilityIds });
+    if (result.vulnerabilityIssueLinksCreate.errors.length > 0) {
+      throw new Error(
+        `Failed to link vulnerability to issue: ${result.vulnerabilityIssueLinksCreate.errors.join(", ")}`
+      );
+    }
+    return result.vulnerabilityIssueLinksCreate.issue;
+  }
+};
+
+// src/client/todos.ts
+var LIST_TODOS_QUERY = `
+  query listTodos(
+    $state: [TodoStateEnum!]
+    $action: [TodoActionEnum!]
+    $type: [TodoTargetEnum!]
+    $projectId: [ID!]
+    $groupId: [ID!]
+    $authorId: [ID!]
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    currentUser {
+      todos(
+        state: $state
+        action: $action
+        type: $type
+        projectId: $projectId
+        groupId: $groupId
+        authorId: $authorId
+        first: $first
+        after: $after
+        last: $last
+        before: $before
+      ) {
+        count
+        pageInfo {
+          hasNextPage
+          hasPreviousPage
+          startCursor
+          endCursor
+        }
+        nodes {
+          id
+          body
+          state
+          action
+          createdAt
+          targetType
+          targetUrl
+          snoozedUntil
+          project {
+            id
+            name
+            fullPath
+          }
+          group {
+            id
+            name
+            fullPath
+          }
+          author {
+            id
+            username
+            name
+            avatarUrl
+          }
+        }
+      }
+    }
+  }
+`;
+var TodosClient = class extends GitLabApiClient {
+  async listTodos(options) {
+    if (options?.first !== void 0 && options?.last !== void 0) {
+      throw new Error(
+        'Cannot specify both "first" and "last" pagination parameters. Use "first"/"after" for forward pagination or "last"/"before" for backward pagination.'
+      );
+    }
+    const variables = {};
+    if (options?.first !== void 0) {
+      variables.first = options.first;
+    } else if (options?.last === void 0) {
+      variables.first = 20;
+    }
+    if (options?.after) variables.after = options.after;
+    if (options?.last !== void 0) variables.last = options.last;
+    if (options?.before) variables.before = options.before;
+    if (options?.action) {
+      variables.action = [this.mapTodoAction(options.action)];
+    }
+    if (options?.author_id) {
+      variables.authorId = [`gid://gitlab/User/${options.author_id}`];
+    }
+    if (options?.project_id) {
+      variables.projectId = [options.project_id];
+    }
+    if (options?.group_id) {
+      variables.groupId = [options.group_id];
+    }
+    if (options?.state) {
+      variables.state = [options.state.toLowerCase()];
+    }
+    if (options?.type) {
+      variables.type = [this.mapTodoTargetType(options.type)];
+    }
+    const result = await this.fetchGraphQL(LIST_TODOS_QUERY, variables);
+    const todos = result.currentUser.todos;
+    return {
+      todos
+    };
+  }
+  mapTodoAction(action) {
+    const actionMap = {
+      assigned: "ASSIGNED",
+      mentioned: "MENTIONED",
+      build_failed: "BUILD_FAILED",
+      marked: "MARKED",
+      approval_required: "APPROVAL_REQUIRED",
+      unmergeable: "UNMERGEABLE",
+      directly_addressed: "DIRECTLY_ADDRESSED",
+      merge_train_removed: "MERGE_TRAIN_REMOVED",
+      review_requested: "REVIEW_REQUESTED"
+    };
+    return actionMap[action] || action.toUpperCase();
+  }
+  mapTodoTargetType(type) {
+    const typeMap = {
+      Issue: "ISSUE",
+      MergeRequest: "MERGEREQUEST",
+      "DesignManagement::Design": "DESIGN",
+      Alert: "ALERT",
+      Commit: "COMMIT",
+      Epic: "EPIC"
+    };
+    return typeMap[type] || type;
+  }
+  async markTodoAsDone(todoId) {
+    try {
+      const result = await this.fetch(
+        "POST",
+        `/todos/${todoId}/mark_as_done`
+      );
+      return { success: true, todo: result };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("404")) {
+        return {
+          success: false,
+          message: `Todo ${todoId} not found. It may have already been marked as done or does not exist.`
+        };
+      }
+      throw error;
+    }
+  }
+  async markAllTodosAsDone() {
+    return this.fetch("POST", "/todos/mark_as_done");
+  }
+  async getTodoCount() {
+    const result = await this.fetchGraphQL(`query { currentUser { todos(state: [pending]) { count } } }`);
+    return { count: result.currentUser.todos.count };
+  }
+};
+
+// src/client/epics.ts
+var LIST_EPIC_NOTES_QUERY = `
+  ${NOTES_FRAGMENT}
+  ${NOTES_CONNECTION_FRAGMENT}
+  query listEpicNotes(
+    $groupPath: ID!
+    $epicIid: String!
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    group(fullPath: $groupPath) {
+      epic(iid: $epicIid) {
+        notes(
+          first: $first
+          after: $after
+          last: $last
+          before: $before
+        ) {
+          ...NotesConnectionFields
+        }
+      }
+    }
+  }
+`;
+var LIST_EPIC_DISCUSSIONS_QUERY = `
+  ${DISCUSSION_NOTE_FRAGMENT}
+  ${DISCUSSION_FRAGMENT}
+  ${DISCUSSIONS_CONNECTION_FRAGMENT}
+  query listEpicDiscussions(
+    $groupPath: ID!
+    $epicIid: String!
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    group(fullPath: $groupPath) {
+      epic(iid: $epicIid) {
+        discussions(
+          first: $first
+          after: $after
+          last: $last
+          before: $before
+        ) {
+          ...DiscussionsConnectionFields
+        }
+      }
+    }
+  }
+`;
+var EpicsClient = class extends GitLabApiClient {
+  async getEpic(groupId, epicIid) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch("GET", `/groups/${encodedGroup}/epics/${epicIid}`);
+  }
+  async listEpics(options) {
+    const encodedGroup = encodeURIComponent(options.groupId);
+    const params = new URLSearchParams();
+    params.set("per_page", String(options.limit || 20));
+    if (options.state) params.set("state", options.state);
+    if (options.author_id) params.set("author_id", String(options.author_id));
+    if (options.labels) params.set("labels", options.labels);
+    if (options.search) params.set("search", options.search);
+    return this.fetch("GET", `/groups/${encodedGroup}/epics?${params}`);
+  }
+  async createEpic(groupId, options) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch("POST", `/groups/${encodedGroup}/epics`, options);
+  }
+  async updateEpic(groupId, epicIid, options) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "PUT",
+      `/groups/${encodedGroup}/epics/${epicIid}`,
+      options
+    );
+  }
+  async listEpicIssues(groupId, epicIid) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "GET",
+      `/groups/${encodedGroup}/epics/${epicIid}/issues`
+    );
+  }
+  async addIssueToEpic(groupId, epicIid, issueId) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "POST",
+      `/groups/${encodedGroup}/epics/${epicIid}/issues/${issueId}`
+    );
+  }
+  async removeIssueFromEpic(groupId, epicIid, epicIssueId) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "DELETE",
+      `/groups/${encodedGroup}/epics/${epicIid}/issues/${epicIssueId}`
+    );
+  }
+  /**
+   * List notes on an epic using GraphQL API with pagination support
+   */
+  async listEpicNotes(groupId, epicIid, options) {
+    const variables = {
+      groupPath: groupId,
+      epicIid: String(epicIid),
+      ...buildPaginationVariables(options)
+    };
+    const result = await this.fetchGraphQL(LIST_EPIC_NOTES_QUERY, variables);
+    const notes = result.group?.epic?.notes;
+    if (!notes) {
+      throw new Error("Epic not found or access denied");
+    }
+    return {
+      notes,
+      pageInfo: notes.pageInfo,
+      totalCount: notes.count
+    };
+  }
+  /**
+   * List discussions on an epic using GraphQL API with pagination support
+   */
+  async listEpicDiscussions(groupId, epicIid, options) {
+    const variables = {
+      groupPath: groupId,
+      epicIid: String(epicIid),
+      ...buildDiscussionsPaginationVariables(options)
+    };
+    const result = await this.fetchGraphQL(LIST_EPIC_DISCUSSIONS_QUERY, variables);
+    const discussions = result.group?.epic?.discussions;
+    if (!discussions) {
+      throw new Error("Epic not found or access denied");
+    }
+    return { discussions };
+  }
+  async getEpicDiscussion(groupId, epicIid, discussionId) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "GET",
+      `/groups/${encodedGroup}/epics/${epicIid}/discussions/${discussionId}`
+    );
+  }
+  async createEpicNote(groupId, epicIid, body, discussionId) {
+    const encodedGroup = encodeURIComponent(groupId);
+    if (discussionId) {
+      return this.fetch(
+        "POST",
+        `/groups/${encodedGroup}/epics/${epicIid}/discussions/${discussionId}/notes`,
+        { body }
+      );
+    }
+    return this.fetch(
+      "POST",
+      `/groups/${encodedGroup}/epics/${epicIid}/notes`,
+      { body }
+    );
+  }
+  async getEpicNote(groupId, epicIid, noteId) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "GET",
+      `/groups/${encodedGroup}/epics/${epicIid}/notes/${noteId}`
+    );
+  }
+};
+
+// src/client/snippets.ts
+var LIST_SNIPPET_NOTES_QUERY = `
+  ${NOTES_FRAGMENT}
+  ${NOTES_CONNECTION_FRAGMENT}
+  query listSnippetNotes(
+    $snippetGid: SnippetID!
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    snippets(ids: [$snippetGid]) {
+      nodes {
+        notes(
+          first: $first
+          after: $after
+          last: $last
+          before: $before
+        ) {
+          ...NotesConnectionFields
+        }
+      }
+    }
+  }
+`;
+var LIST_SNIPPET_DISCUSSIONS_QUERY = `
+  ${DISCUSSION_NOTE_FRAGMENT}
+  ${DISCUSSION_FRAGMENT}
+  ${DISCUSSIONS_CONNECTION_FRAGMENT}
+  query listSnippetDiscussions(
+    $snippetGid: SnippetID!
+    $first: Int
+    $after: String
+    $last: Int
+    $before: String
+  ) {
+    snippets(ids: [$snippetGid]) {
+      nodes {
+        discussions(
+          first: $first
+          after: $after
+          last: $last
+          before: $before
+        ) {
+          ...DiscussionsConnectionFields
+        }
+      }
+    }
+  }
+`;
+var SnippetsClient = class extends GitLabApiClient {
+  /**
+   * List notes on a snippet using GraphQL API with pagination support
+   */
+  async listSnippetNotes(projectId, snippetId, options) {
+    const variables = {
+      snippetGid: `gid://gitlab/ProjectSnippet/${snippetId}`,
+      ...buildPaginationVariables(options)
+    };
+    const result = await this.fetchGraphQL(LIST_SNIPPET_NOTES_QUERY, variables);
+    const notes = result.snippets.nodes[0]?.notes || {
+      nodes: [],
+      pageInfo: {
+        hasNextPage: false,
+        hasPreviousPage: false,
+        startCursor: null,
+        endCursor: null
+      },
+      count: 0
+    };
+    return {
+      notes,
+      pageInfo: notes.pageInfo,
+      totalCount: notes.count
+    };
+  }
+  /**
+   * List discussions on a snippet using GraphQL API with pagination support
+   */
+  async listSnippetDiscussions(projectId, snippetId, options) {
+    const variables = {
+      snippetGid: `gid://gitlab/ProjectSnippet/${snippetId}`,
+      ...buildDiscussionsPaginationVariables(options)
+    };
+    const result = await this.fetchGraphQL(LIST_SNIPPET_DISCUSSIONS_QUERY, variables);
+    const discussions = result.snippets.nodes[0]?.discussions || {
+      nodes: [],
+      pageInfo: {
+        hasNextPage: false,
+        hasPreviousPage: false,
+        startCursor: null,
+        endCursor: null
+      }
+    };
+    return { discussions };
+  }
+  async getSnippetDiscussion(projectId, snippetId, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/snippets/${snippetId}/discussions/${discussionId}`
+    );
+  }
+  async createSnippetNote(projectId, snippetId, body, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    if (discussionId) {
+      return this.fetch(
+        "POST",
+        `/projects/${encodedProject}/snippets/${snippetId}/discussions/${discussionId}/notes`,
+        { body }
+      );
+    }
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/snippets/${snippetId}/notes`,
+      { body }
+    );
+  }
+  async createSnippetDiscussion(projectId, snippetId, body) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "POST",
+      `/projects/${encodedProject}/snippets/${snippetId}/discussions`,
+      { body }
+    );
+  }
+};
+
+// src/client/discussions.ts
+var DiscussionsClient = class extends GitLabApiClient {
+  /**
+   * Universal method to reply to any discussion thread
+   * Supports: merge requests, issues, epics, commits, snippets
+   */
+  async replyToDiscussion(resourceType, resourceId, discussionId, body) {
+    switch (resourceType) {
+      case "merge_request": {
+        if (!resourceId.projectId || !resourceId.iid) {
+          throw new Error("projectId and iid are required for merge_request discussions");
+        }
+        const encodedProject = this.encodeProjectId(resourceId.projectId);
+        return this.fetch(
+          "POST",
+          `/projects/${encodedProject}/merge_requests/${resourceId.iid}/discussions/${discussionId}/notes`,
+          { body }
+        );
+      }
+      case "issue": {
+        if (!resourceId.projectId || !resourceId.iid) {
+          throw new Error("projectId and iid are required for issue discussions");
+        }
+        const encodedProject = this.encodeProjectId(resourceId.projectId);
+        return this.fetch(
+          "POST",
+          `/projects/${encodedProject}/issues/${resourceId.iid}/discussions/${discussionId}/notes`,
+          { body }
+        );
+      }
+      case "epic": {
+        if (!resourceId.groupId || !resourceId.iid) {
+          throw new Error("groupId and iid are required for epic discussions");
+        }
+        const encodedGroup = encodeURIComponent(resourceId.groupId);
+        return this.fetch(
+          "POST",
+          `/groups/${encodedGroup}/epics/${resourceId.iid}/discussions/${discussionId}/notes`,
+          { body }
+        );
+      }
+      case "commit": {
+        if (!resourceId.projectId || !resourceId.sha) {
+          throw new Error("projectId and sha are required for commit discussions");
+        }
+        const encodedProject = this.encodeProjectId(resourceId.projectId);
+        return this.fetch(
+          "POST",
+          `/projects/${encodedProject}/repository/commits/${resourceId.sha}/discussions/${discussionId}/notes`,
+          { body }
+        );
+      }
+      case "snippet": {
+        if (!resourceId.projectId || !resourceId.snippetId) {
+          throw new Error("projectId and snippetId are required for snippet discussions");
+        }
+        const encodedProject = this.encodeProjectId(resourceId.projectId);
+        return this.fetch(
+          "POST",
+          `/projects/${encodedProject}/snippets/${resourceId.snippetId}/discussions/${discussionId}/notes`,
+          { body }
+        );
+      }
+      default:
+        throw new Error(`Unsupported resource type: ${resourceType}`);
+    }
+  }
+  /**
+   * Universal method to get a specific discussion from any resource type
+   * Supports: merge requests, issues, epics, commits, snippets
+   */
+  async getDiscussion(resourceType, resourceId, discussionId) {
+    switch (resourceType) {
+      case "merge_request": {
+        if (!resourceId.projectId || !resourceId.iid) {
+          throw new Error("projectId and iid are required for merge_request discussions");
+        }
+        const encodedProject = this.encodeProjectId(resourceId.projectId);
+        return this.fetch(
+          "GET",
+          `/projects/${encodedProject}/merge_requests/${resourceId.iid}/discussions/${discussionId}`
+        );
+      }
+      case "issue": {
+        if (!resourceId.projectId || !resourceId.iid) {
+          throw new Error("projectId and iid are required for issue discussions");
+        }
+        const encodedProject = this.encodeProjectId(resourceId.projectId);
+        return this.fetch(
+          "GET",
+          `/projects/${encodedProject}/issues/${resourceId.iid}/discussions/${discussionId}`
+        );
+      }
+      case "epic": {
+        if (!resourceId.groupId || !resourceId.iid) {
+          throw new Error("groupId and iid are required for epic discussions");
+        }
+        const encodedGroup = encodeURIComponent(resourceId.groupId);
+        return this.fetch(
+          "GET",
+          `/groups/${encodedGroup}/epics/${resourceId.iid}/discussions/${discussionId}`
+        );
+      }
+      case "commit": {
+        if (!resourceId.projectId || !resourceId.sha) {
+          throw new Error("projectId and sha are required for commit discussions");
+        }
+        const encodedProject = this.encodeProjectId(resourceId.projectId);
+        return this.fetch(
+          "GET",
+          `/projects/${encodedProject}/repository/commits/${resourceId.sha}/discussions/${discussionId}`
+        );
+      }
+      case "snippet": {
+        if (!resourceId.projectId || !resourceId.snippetId) {
+          throw new Error("projectId and snippetId are required for snippet discussions");
+        }
+        const encodedProject = this.encodeProjectId(resourceId.projectId);
+        return this.fetch(
+          "GET",
+          `/projects/${encodedProject}/snippets/${resourceId.snippetId}/discussions/${discussionId}`
+        );
+      }
+      default:
+        throw new Error(`Unsupported resource type: ${resourceType}`);
+    }
+  }
+};
+
+// src/client/audit.ts
+var AuditClient = class extends GitLabApiClient {
+  /**
+   * List audit events for a project
+   * Requires: Project owner role
+   * API: GET /projects/:id/audit_events
+   */
+  async listProjectAuditEvents(projectId, options = {}) {
+    const encodedId = this.encodeProjectId(projectId);
+    const params = new URLSearchParams();
+    if (options.created_after) params.append("created_after", options.created_after);
+    if (options.created_before) params.append("created_before", options.created_before);
+    if (options.entity_type) params.append("entity_type", options.entity_type);
+    if (options.entity_id) params.append("entity_id", options.entity_id.toString());
+    if (options.author_id) params.append("author_id", options.author_id.toString());
+    if (options.per_page) params.append("per_page", options.per_page.toString());
+    if (options.page) params.append("page", options.page.toString());
+    const query = params.toString();
+    const path2 = `/projects/${encodedId}/audit_events${query ? `?${query}` : ""}`;
+    return this.fetch("GET", path2);
+  }
+  /**
+   * List audit events for a group
+   * Requires: Group owner role
+   * API: GET /groups/:id/audit_events
+   */
+  async listGroupAuditEvents(groupId, options = {}) {
+    const encodedId = encodeURIComponent(groupId);
+    const params = new URLSearchParams();
+    if (options.created_after) params.append("created_after", options.created_after);
+    if (options.created_before) params.append("created_before", options.created_before);
+    if (options.entity_type) params.append("entity_type", options.entity_type);
+    if (options.entity_id) params.append("entity_id", options.entity_id.toString());
+    if (options.author_id) params.append("author_id", options.author_id.toString());
+    if (options.per_page) params.append("per_page", options.per_page.toString());
+    if (options.page) params.append("page", options.page.toString());
+    const query = params.toString();
+    const path2 = `/groups/${encodedId}/audit_events${query ? `?${query}` : ""}`;
+    return this.fetch("GET", path2);
+  }
+  /**
+   * List instance-level audit events
+   * Requires: Administrator access
+   * API: GET /audit_events
+   */
+  async listInstanceAuditEvents(options = {}) {
+    const params = new URLSearchParams();
+    if (options.created_after) params.append("created_after", options.created_after);
+    if (options.created_before) params.append("created_before", options.created_before);
+    if (options.entity_type) params.append("entity_type", options.entity_type);
+    if (options.entity_id) params.append("entity_id", options.entity_id.toString());
+    if (options.author_id) params.append("author_id", options.author_id.toString());
+    if (options.per_page) params.append("per_page", options.per_page.toString());
+    if (options.page) params.append("page", options.page.toString());
+    const query = params.toString();
+    const path2 = `/audit_events${query ? `?${query}` : ""}`;
+    return this.fetch("GET", path2);
+  }
+};
+
+// src/client/award-emoji.ts
+var AwardEmojiClient = class extends GitLabApiClient {
+  /**
+   * Build the base path for award emoji operations
+   */
+  buildAwardEmojiPath(resource) {
+    const encodedProject = this.encodeProjectId(resource.projectId);
+    let basePath;
+    switch (resource.resourceType) {
+      case "merge_request":
+        basePath = `/projects/${encodedProject}/merge_requests/${resource.resourceIid}`;
+        break;
+      case "issue":
+        basePath = `/projects/${encodedProject}/issues/${resource.resourceIid}`;
+        break;
+      case "snippet":
+        basePath = `/projects/${encodedProject}/snippets/${resource.resourceIid}`;
+        break;
+    }
+    if (resource.noteId) {
+      return `${basePath}/notes/${resource.noteId}/award_emoji`;
+    }
+    return `${basePath}/award_emoji`;
+  }
+  /**
+   * List all award emoji on a resource or note
+   */
+  async listAwardEmoji(resource) {
+    const path2 = this.buildAwardEmojiPath(resource);
+    return this.fetch("GET", path2);
+  }
+  /**
+   * Get a single award emoji by ID
+   */
+  async getAwardEmoji(resource, awardId) {
+    const path2 = `${this.buildAwardEmojiPath(resource)}/${awardId}`;
+    return this.fetch("GET", path2);
+  }
+  /**
+   * Add an award emoji (reaction) to a resource or note
+   *
+   * @param resource - The resource to add the emoji to
+   * @param name - The emoji name without colons (e.g., 'thumbsup', 'rocket', 'eyes')
+   */
+  async createAwardEmoji(resource, name) {
+    const path2 = this.buildAwardEmojiPath(resource);
+    return this.fetch("POST", path2, { name });
+  }
+  /**
+   * Remove an award emoji from a resource or note
+   */
+  async deleteAwardEmoji(resource, awardId) {
+    const path2 = `${this.buildAwardEmojiPath(resource)}/${awardId}`;
+    await this.fetch("DELETE", path2);
+  }
+};
+
+// src/client/index.ts
+var UnifiedGitLabClient = class extends GitLabApiClient {
+};
+function applyMixins(derivedCtor, constructors) {
+  constructors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      Object.defineProperty(
+        derivedCtor.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null)
+      );
+    });
+  });
+}
+applyMixins(UnifiedGitLabClient, [
+  MergeRequestsClient,
+  IssuesClient,
+  WorkItemsClient,
+  PipelinesClient,
+  RepositoryClient,
+  SearchClient,
+  ProjectsClient,
+  UsersClient,
+  WikisClient,
+  SecurityClient,
+  TodosClient,
+  EpicsClient,
+  SnippetsClient,
+  DiscussionsClient,
+  AuditClient,
+  AwardEmojiClient
+]);
+
+// src/utils.ts
+function readTokenFromAuthStorage() {
+  try {
+    const authPath = path.join(os.homedir(), ".local", "share", "opencode", "auth.json");
+    if (!fs.existsSync(authPath)) {
+      return void 0;
+    }
+    const authData = JSON.parse(fs.readFileSync(authPath, "utf-8"));
+    const gitlabAuth = authData?.gitlab;
+    if (!gitlabAuth) {
+      return void 0;
+    }
+    if (gitlabAuth.type === "oauth" && gitlabAuth.access) {
+      return gitlabAuth.access;
+    }
+    if (gitlabAuth.type === "api" && gitlabAuth.key) {
+      return gitlabAuth.key;
+    }
+    return gitlabAuth.token || void 0;
+  } catch (error) {
+    return void 0;
+  }
+}
+function getGitLabClient() {
+  let token = process.env["GITLAB_TOKEN"];
+  if (!token) {
+    token = readTokenFromAuthStorage();
+  }
+  if (!token) {
+    throw new Error(
+      "GitLab API token not found. Set GITLAB_TOKEN environment variable or configure it in OpenCode auth storage (~/.local/share/opencode/auth.json)."
+    );
+  }
+  const instanceUrl = process.env["GITLAB_INSTANCE_URL"] || "https://gitlab.com";
+  return new UnifiedGitLabClient(instanceUrl, token);
+}
+
+// src/tools/merge-requests.ts
+var z = tool.schema;
+var mergeRequestTools = {
+  gitlab_get_merge_request: tool({
+    description: `Get details of a specific merge request by project and MR IID.
+Returns: title, description, state, author, assignees, reviewers, labels, diff stats, and discussion notes.`,
+    args: {
+      project_id: z.string().describe('The project ID or URL-encoded path (e.g., "gitlab-org/gitlab" or "123")'),
+      mr_iid: z.number().describe("The internal ID of the merge request within the project"),
+      include_changes: z.boolean().optional().describe("Whether to include the list of changed files (default: false)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const mr = await client.getMergeRequest(args.project_id, args.mr_iid, args.include_changes);
+      return JSON.stringify(mr, null, 2);
+    }
+  }),
+  gitlab_list_merge_requests: tool({
+    description: `List merge requests for a project or search globally.
+Can filter by state (opened, closed, merged, all), scope (assigned_to_me, created_by_me), and labels.`,
+    args: {
+      project_id: z.string().optional().describe("The project ID or path. If not provided, searches globally."),
+      state: z.enum(["opened", "closed", "merged", "all"]).optional().describe("Filter by MR state (default: opened)"),
+      scope: z.enum(["assigned_to_me", "created_by_me", "all"]).optional().describe("Filter by scope"),
+      search: z.string().optional().describe("Search MRs by title or description"),
+      labels: z.string().optional().describe("Comma-separated list of labels to filter by"),
+      limit: z.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const mrs = await client.listMergeRequests({
+        projectId: args.project_id,
+        state: args.state,
+        scope: args.scope,
+        search: args.search,
+        labels: args.labels,
+        limit: args.limit
+      });
+      return JSON.stringify(mrs, null, 2);
+    }
+  }),
+  gitlab_get_mr_changes: tool({
+    description: `Get the file changes (diff) for a merge request.
+Returns the list of files changed with their diffs.`,
+    args: {
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      mr_iid: z.number().describe("The internal ID of the merge request")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const changes = await client.getMrChanges(args.project_id, args.mr_iid);
+      return JSON.stringify(changes, null, 2);
+    }
+  }),
+  gitlab_create_merge_request: tool({
+    description: `Create a new merge request.
+Returns the created merge request with all details.`,
+    args: {
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      source_branch: z.string().describe("The source branch name"),
+      target_branch: z.string().describe("The target branch name"),
+      title: z.string().describe("The title of the merge request"),
+      description: z.string().optional().describe("The description of the merge request (supports Markdown)"),
+      assignee_ids: z.array(z.number()).optional().describe("Array of user IDs to assign"),
+      reviewer_ids: z.array(z.number()).optional().describe("Array of user IDs to review"),
+      labels: z.string().optional().describe("Comma-separated list of labels"),
+      milestone_id: z.number().optional().describe("The ID of a milestone"),
+      remove_source_branch: z.boolean().optional().describe("Remove source branch after merge (default: false)"),
+      squash: z.boolean().optional().describe("Squash commits on merge (default: false)"),
+      allow_collaboration: z.boolean().optional().describe("Allow commits from members who can merge to the target branch")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const mr = await client.createMergeRequest(args.project_id, {
+        source_branch: args.source_branch,
+        target_branch: args.target_branch,
+        title: args.title,
+        description: args.description,
+        assignee_ids: args.assignee_ids,
+        reviewer_ids: args.reviewer_ids,
+        labels: args.labels,
+        milestone_id: args.milestone_id,
+        remove_source_branch: args.remove_source_branch,
+        squash: args.squash,
+        allow_collaboration: args.allow_collaboration
+      });
+      return JSON.stringify(mr, null, 2);
+    }
+  }),
+  gitlab_update_merge_request: tool({
+    description: `Update an existing merge request.
+Can update title, description, state, assignees, reviewers, labels, and more.`,
+    args: {
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      mr_iid: z.number().describe("The internal ID of the merge request"),
+      title: z.string().optional().describe("The new title"),
+      description: z.string().optional().describe("The new description (supports Markdown)"),
+      state_event: z.enum(["close", "reopen"]).optional().describe("Change the state (close or reopen)"),
+      assignee_ids: z.array(z.number()).optional().describe("Array of user IDs to assign"),
+      reviewer_ids: z.array(z.number()).optional().describe("Array of user IDs to review"),
+      labels: z.string().optional().describe("Comma-separated list of labels"),
+      milestone_id: z.number().optional().describe("The ID of a milestone"),
+      remove_source_branch: z.boolean().optional().describe("Remove source branch after merge"),
+      squash: z.boolean().optional().describe("Squash commits on merge"),
+      target_branch: z.string().optional().describe("The target branch name")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const mr = await client.updateMergeRequest(args.project_id, args.mr_iid, {
+        title: args.title,
+        description: args.description,
+        state_event: args.state_event,
+        assignee_ids: args.assignee_ids,
+        reviewer_ids: args.reviewer_ids,
+        labels: args.labels,
+        milestone_id: args.milestone_id,
+        remove_source_branch: args.remove_source_branch,
+        squash: args.squash,
+        target_branch: args.target_branch
+      });
+      return JSON.stringify(mr, null, 2);
+    }
+  }),
+  gitlab_get_mr_details: tool({
+    description: `Get additional details for a merge request.
+
+Detail types:
+- commits: List all commits in the MR
+- pipelines: List all pipelines that ran for the MR
+
+Examples:
+- Get commits: detail_type="commits", project_id="group/project", mr_iid=123
+- Get pipelines: detail_type="pipelines", project_id="group/project", mr_iid=123`,
+    args: {
+      detail_type: z.enum(["commits", "pipelines"]).describe("Type of details to fetch"),
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      mr_iid: z.number().describe("The internal ID of the merge request")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      switch (args.detail_type) {
+        case "commits": {
+          const commits = await client.getMrCommits(args.project_id, args.mr_iid);
+          return JSON.stringify(commits, null, 2);
+        }
+        case "pipelines": {
+          const pipelines = await client.getMrPipelines(args.project_id, args.mr_iid);
+          return JSON.stringify(pipelines, null, 2);
+        }
+      }
+    }
+  }),
+  gitlab_list_merge_request_diffs: tool({
+    description: `List merge request diffs with pagination support.
+Returns the list of file diffs for a merge request, with support for pagination to handle large changesets.
+This is useful when you need to process diffs in chunks or when the MR has many changed files.`,
+    args: {
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      mr_iid: z.number().describe("The internal ID of the merge request"),
+      page: z.number().optional().describe("Page number for pagination (default: 1)"),
+      per_page: z.number().optional().describe("Number of diffs per page (default: 20, max: 100)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const diffs = await client.listMergeRequestDiffs(args.project_id, args.mr_iid, {
+        page: args.page,
+        per_page: args.per_page
+      });
+      return JSON.stringify(diffs, null, 2);
+    }
+  }),
+  gitlab_add_mr_reviewer: tool({
+    description: `Add a reviewer to a merge request without affecting existing reviewers.
+This is safer than gitlab_update_merge_request when you only want to add a single reviewer,
+as it preserves all existing reviewers.`,
+    args: {
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      mr_iid: z.number().describe("The internal ID of the merge request"),
+      reviewer_id: z.number().describe("The user ID of the reviewer to add")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const mr = await client.addReviewer(args.project_id, args.mr_iid, args.reviewer_id);
+      return JSON.stringify(mr, null, 2);
+    }
+  }),
+  gitlab_remove_mr_reviewer: tool({
+    description: `Remove a reviewer from a merge request without affecting other reviewers.
+This is safer than gitlab_update_merge_request when you only want to remove a single reviewer,
+as it preserves all other reviewers.`,
+    args: {
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      mr_iid: z.number().describe("The internal ID of the merge request"),
+      reviewer_id: z.number().describe("The user ID of the reviewer to remove")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const mr = await client.removeReviewer(args.project_id, args.mr_iid, args.reviewer_id);
+      return JSON.stringify(mr, null, 2);
+    }
+  }),
+  gitlab_set_mr_auto_merge: tool({
+    description: `Enable auto-merge (MWPS - Merge When Pipeline Succeeds) on a merge request.
+Uses the GitLab GraphQL API mergeRequestAccept mutation with a merge strategy.
+The MR will be automatically merged when all required conditions are met.
+Requires the MR to be approved and have a passing pipeline (depending on project settings).
+Note: You must provide the current HEAD SHA of the MR to prevent race conditions.`,
+    args: {
+      project_id: z.string().describe('The project ID or path (e.g., "gitlab-org/gitlab")'),
+      mr_iid: z.number().describe("The internal ID of the merge request"),
+      sha: z.string().describe(
+        "The HEAD SHA of the merge request. Get this from the MR details (diff_refs.head_sha or sha field)."
+      ),
+      strategy: z.enum(["MERGE_WHEN_CHECKS_PASS", "ADD_TO_MERGE_TRAIN_WHEN_CHECKS_PASS"]).optional().describe(
+        "Auto-merge strategy. MERGE_WHEN_CHECKS_PASS (default) waits for all checks including approvals. ADD_TO_MERGE_TRAIN_WHEN_CHECKS_PASS adds to merge train when checks pass."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const result = await client.setAutoMerge(
+        args.project_id,
+        args.mr_iid,
+        args.sha,
+        args.strategy || "MERGE_WHEN_CHECKS_PASS"
+      );
+      return JSON.stringify(result, null, 2);
+    }
+  }),
+  gitlab_approve_merge_request: tool({
+    description: `Approve a merge request.
+Adds the current user's approval to the merge request.
+Requires at least Developer role on the project.
+Returns the updated approval state including approved_by list.`,
+    args: {
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      mr_iid: z.number().describe("The internal ID of the merge request"),
+      sha: z.string().optional().describe(
+        "The HEAD SHA of the MR. If provided, the approval will only succeed if this matches the current HEAD, preventing approval of outdated code."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const result = await client.approveMergeRequest(args.project_id, args.mr_iid, args.sha);
+      return JSON.stringify(result, null, 2);
+    }
+  }),
+  gitlab_unapprove_merge_request: tool({
+    description: `Unapprove (revoke approval from) a merge request.
+Removes the current user's approval from the merge request.
+Only the user who approved can unapprove; you cannot remove others' approvals.
+Returns the updated approval state.`,
+    args: {
+      project_id: z.string().describe("The project ID or URL-encoded path"),
+      mr_iid: z.number().describe("The internal ID of the merge request")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const result = await client.unapproveMergeRequest(args.project_id, args.mr_iid);
+      return JSON.stringify(result, null, 2);
+    }
+  })
+};
+
+// src/tools/issues.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+var z2 = tool2.schema;
+var issueTools = {
+  gitlab_create_issue: tool2({
+    description: `Create a new issue in a GitLab project.
+Returns the created issue with all details including IID, web URL, and metadata.`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      title: z2.string().describe("The title of the issue"),
+      description: z2.string().optional().describe("The description of the issue (supports Markdown)"),
+      assignee_ids: z2.array(z2.number()).optional().describe("Array of user IDs to assign the issue to"),
+      milestone_id: z2.number().optional().describe("The ID of the milestone to assign the issue to"),
+      labels: z2.string().optional().describe('Comma-separated list of label names (e.g., "bug,critical")'),
+      due_date: z2.string().optional().describe('Due date for the issue in YYYY-MM-DD format (e.g., "2025-12-31")'),
+      confidential: z2.boolean().optional().describe("Whether the issue should be confidential"),
+      weight: z2.number().optional().describe("The weight of the issue (for issue boards)"),
+      epic_id: z2.number().optional().describe("The ID of the epic to add the issue to (Premium/Ultimate)"),
+      issue_type: z2.enum(["issue", "incident", "test_case", "task"]).optional().describe("The type of issue (default: issue)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const issue = await client.createIssue(args.project_id, args.title, {
+        description: args.description,
+        assignee_ids: args.assignee_ids,
+        milestone_id: args.milestone_id,
+        labels: args.labels,
+        due_date: args.due_date,
+        confidential: args.confidential,
+        weight: args.weight,
+        epic_id: args.epic_id,
+        issue_type: args.issue_type
+      });
+      return JSON.stringify(issue, null, 2);
+    }
+  }),
+  gitlab_get_issue: tool2({
+    description: `Get details of a specific issue by project and issue IID.
+Returns: title, description, state, author, assignees, labels, milestone, weight, and comments.`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      issue_iid: z2.number().describe("The internal ID of the issue within the project")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const issue = await client.getIssue(args.project_id, args.issue_iid);
+      return JSON.stringify(issue, null, 2);
+    }
+  }),
+  gitlab_list_issues: tool2({
+    description: `List issues for a project or search globally.
+Can filter by state, labels, assignee, milestone.`,
+    args: {
+      project_id: z2.string().optional().describe("The project ID or path. If not provided, searches globally."),
+      state: z2.enum(["opened", "closed", "all"]).optional().describe("Filter by issue state (default: opened)"),
+      scope: z2.enum(["assigned_to_me", "created_by_me", "all"]).optional().describe("Filter by scope"),
+      search: z2.string().optional().describe("Search issues by title or description"),
+      labels: z2.string().optional().describe("Comma-separated list of labels to filter by"),
+      milestone: z2.string().optional().describe("Filter by milestone title"),
+      limit: z2.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const issues = await client.listIssues({
+        projectId: args.project_id,
+        state: args.state,
+        scope: args.scope,
+        search: args.search,
+        labels: args.labels,
+        milestone: args.milestone,
+        limit: args.limit
+      });
+      return JSON.stringify(issues, null, 2);
+    }
+  })
+};
+
+// src/tools/epics.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+var z3 = tool3.schema;
+function validationError(message) {
+  return JSON.stringify({ error: message }, null, 2);
+}
+var epicTools = {
+  gitlab_get_epic: tool3({
+    description: `Get details of a specific epic by group and epic IID.
+Returns: title, description, state, author, start/end dates, labels, associated issues, and child epics.`,
+    args: {
+      group_id: z3.string().describe(
+        'The group ID or URL-encoded path (e.g., "gitlab-org" or "my-group/my-subgroup")'
+      ),
+      epic_iid: z3.number().describe("The internal ID of the epic within the group")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const epic = await client.getEpic(args.group_id, args.epic_iid);
+      return JSON.stringify(epic, null, 2);
+    }
+  }),
+  gitlab_list_epics: tool3({
+    description: `List epics for a group with filtering capabilities.
+Can filter by state (opened, closed, all), author, labels, and search query.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      state: z3.enum(["opened", "closed", "all"]).optional().describe("Filter by epic state (default: opened)"),
+      author_id: z3.number().optional().describe("Filter by author user ID"),
+      labels: z3.string().optional().describe("Comma-separated list of labels to filter by"),
+      search: z3.string().optional().describe("Search epics by title or description"),
+      limit: z3.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const epics = await client.listEpics({
+        groupId: args.group_id,
+        state: args.state,
+        author_id: args.author_id,
+        labels: args.labels,
+        search: args.search,
+        limit: args.limit
+      });
+      return JSON.stringify(epics, null, 2);
+    }
+  }),
+  gitlab_create_epic: tool3({
+    description: `Create a new epic in a group.
+Returns the created epic with all details.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      title: z3.string().describe("The title of the epic"),
+      description: z3.string().optional().describe("The description of the epic (supports Markdown)"),
+      labels: z3.string().optional().describe("Comma-separated list of labels"),
+      start_date: z3.string().optional().describe("Start date in YYYY-MM-DD format"),
+      end_date: z3.string().optional().describe("Due/end date in YYYY-MM-DD format"),
+      confidential: z3.boolean().optional().describe("Whether the epic is confidential (default: false)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const epic = await client.createEpic(args.group_id, {
+        title: args.title,
+        description: args.description,
+        labels: args.labels,
+        start_date: args.start_date,
+        end_date: args.end_date,
+        confidential: args.confidential
+      });
+      return JSON.stringify(epic, null, 2);
+    }
+  }),
+  gitlab_update_epic: tool3({
+    description: `Update an existing epic.
+Can update title, description, labels, dates, state, and confidentiality.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic"),
+      title: z3.string().optional().describe("The new title"),
+      description: z3.string().optional().describe("The new description (supports Markdown)"),
+      labels: z3.string().optional().describe("Comma-separated list of labels"),
+      start_date: z3.string().optional().describe("Start date in YYYY-MM-DD format"),
+      end_date: z3.string().optional().describe("Due/end date in YYYY-MM-DD format"),
+      state_event: z3.enum(["close", "reopen"]).optional().describe("Change the state (close or reopen)"),
+      confidential: z3.boolean().optional().describe("Whether the epic is confidential")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const epic = await client.updateEpic(args.group_id, args.epic_iid, {
+        title: args.title,
+        description: args.description,
+        labels: args.labels,
+        start_date: args.start_date,
+        end_date: args.end_date,
+        state_event: args.state_event,
+        confidential: args.confidential
+      });
+      return JSON.stringify(epic, null, 2);
+    }
+  }),
+  gitlab_manage_epic_issues: tool3({
+    description: `Manage issues linked to a GitLab epic.
+
+Actions:
+- list: Get all issues associated with the epic
+- add: Link an existing issue to the epic (issue can be from any project within the group hierarchy)
+- remove: Unlink an issue from the epic
+
+Examples:
+- List issues: action="list", group_id="gitlab-org", epic_iid=123
+- Add issue: action="add", group_id="gitlab-org", epic_iid=123, issue_id=456
+- Remove issue: action="remove", group_id="gitlab-org", epic_iid=123, epic_issue_id=789
+
+Note: The epic_issue_id (for remove) is the ID of the epic-issue association, which can be obtained from the list action response.`,
+    args: {
+      action: z3.enum(["list", "add", "remove"]).describe("The action to perform"),
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic within the group"),
+      issue_id: z3.number().optional().describe('The global ID of the issue to add (required for "add" action)'),
+      epic_issue_id: z3.number().optional().describe(
+        'The ID of the epic-issue association to remove (required for "remove" action, from list response)'
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      switch (args.action) {
+        case "list": {
+          const issues = await client.listEpicIssues(args.group_id, args.epic_iid);
+          return JSON.stringify(issues, null, 2);
+        }
+        case "add": {
+          if (args.issue_id === void 0) {
+            return validationError('issue_id is required for "add" action');
+          }
+          const result = await client.addIssueToEpic(args.group_id, args.epic_iid, args.issue_id);
+          return JSON.stringify(result, null, 2);
+        }
+        case "remove": {
+          if (args.epic_issue_id === void 0) {
+            return validationError('epic_issue_id is required for "remove" action');
+          }
+          const result = await client.removeIssueFromEpic(
+            args.group_id,
+            args.epic_iid,
+            args.epic_issue_id
+          );
+          return JSON.stringify(result, null, 2);
+        }
+      }
+    }
+  })
+};
+
+// src/tools/pipelines.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+var z4 = tool4.schema;
+var pipelineTools = {
+  gitlab_list_pipelines: tool4({
+    description: `List pipelines for a project.
+Can filter by status, ref (branch/tag), username.`,
+    args: {
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      status: z4.enum(["running", "pending", "success", "failed", "canceled", "skipped", "manual"]).optional().describe("Filter by pipeline status"),
+      ref: z4.string().optional().describe("Filter by branch or tag name"),
+      limit: z4.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const pipelines = await client.listPipelines(args.project_id, {
+        status: args.status,
+        ref: args.ref,
+        limit: args.limit
+      });
+      return JSON.stringify(pipelines, null, 2);
+    }
+  }),
+  gitlab_get_pipeline: tool4({
+    description: `Get details of a specific pipeline including its jobs.`,
+    args: {
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      pipeline_id: z4.number().describe("The ID of the pipeline")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const pipeline = await client.getPipeline(args.project_id, args.pipeline_id);
+      return JSON.stringify(pipeline, null, 2);
+    }
+  }),
+  gitlab_list_pipeline_jobs: tool4({
+    description: `List jobs for a pipeline, optionally filter by scope (failed, success, etc).`,
+    args: {
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      pipeline_id: z4.number().describe("The ID of the pipeline"),
+      scope: z4.enum([
+        "created",
+        "pending",
+        "running",
+        "failed",
+        "success",
+        "canceled",
+        "skipped",
+        "manual"
+      ]).optional().describe("Filter jobs by scope/status")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const jobs = await client.listPipelineJobs(args.project_id, args.pipeline_id, args.scope);
+      return JSON.stringify(jobs, null, 2);
+    }
+  }),
+  gitlab_get_job_log: tool4({
+    description: `Get the log/trace output of a specific CI job.`,
+    args: {
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      job_id: z4.number().describe("The ID of the job")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      return client.getJobLog(args.project_id, args.job_id);
+    }
+  }),
+  gitlab_retry_job: tool4({
+    description: `Retry a failed or canceled CI job.`,
+    args: {
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      job_id: z4.number().describe("The ID of the job to retry")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const job = await client.retryJob(args.project_id, args.job_id);
+      return JSON.stringify(job, null, 2);
+    }
+  }),
+  gitlab_get_pipeline_failing_jobs: tool4({
+    description: `Get all failed jobs in a pipeline.
+Returns only the jobs that have failed, making it easier to debug pipeline failures.`,
+    args: {
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      pipeline_id: z4.number().describe("The ID of the pipeline")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const jobs = await client.getPipelineFailingJobs(args.project_id, args.pipeline_id);
+      return JSON.stringify(jobs, null, 2);
+    }
+  }),
+  gitlab_lint_ci_config: tool4({
+    description: `Validate a CI/CD YAML configuration against GitLab CI syntax rules.
+This validates the configuration in the context of the project, including:
+- Using the project's CI/CD variables
+- Searching the project's files for include:local entries
+- Optionally simulating pipeline creation (dry_run)
+- Optionally including the list of jobs that would be created
+
+Modes:
+- content: Validate provided YAML content (requires 'content' parameter)
+- existing: Validate the existing .gitlab-ci.yml from the repository
+
+Returns validation result with:
+- valid: boolean indicating if configuration is valid
+- errors: array of error messages
+- warnings: array of warning messages
+- merged_yaml: the final merged YAML after processing includes (optional)
+- includes: list of included files (for existing mode)
+- jobs: list of jobs that would be created (optional, requires include_jobs=true)
+
+Examples:
+- Validate content: mode="content", project_id="group/project", content="stages: [build]..."
+- Validate existing: mode="existing", project_id="group/project"`,
+    args: {
+      mode: z4.enum(["content", "existing"]).describe('Validation mode: "content" for provided YAML, "existing" for repo file'),
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      content: z4.string().optional().describe('The CI/CD configuration content (YAML as string) - required for mode="content"'),
+      dry_run: z4.boolean().optional().describe("Run pipeline creation simulation instead of just static check (default: false)"),
+      include_jobs: z4.boolean().optional().describe("Include list of jobs that would be created in the response (default: false)"),
+      ref: z4.string().optional().describe(
+        "Branch or tag context to use for validation (defaults to project default branch)"
+      ),
+      content_ref: z4.string().optional().describe(
+        'For mode="existing": Commit SHA, branch or tag to get CI config from (defaults to project default branch)'
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      switch (args.mode) {
+        case "content": {
+          if (!args.content) {
+            return JSON.stringify({ error: 'content is required when mode is "content"' }, null, 2);
+          }
+          const result = await client.lintCiConfig(args.project_id, args.content, {
+            dry_run: args.dry_run,
+            include_jobs: args.include_jobs,
+            ref: args.ref
+          });
+          return JSON.stringify(result, null, 2);
+        }
+        case "existing": {
+          const result = await client.lintExistingCiConfig(args.project_id, {
+            content_ref: args.content_ref,
+            dry_run: args.dry_run,
+            dry_run_ref: args.ref,
+            include_jobs: args.include_jobs
+          });
+          return JSON.stringify(result, null, 2);
+        }
+      }
+    }
+  })
+};
+
+// src/tools/repository.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
+var z5 = tool5.schema;
+var repositoryTools = {
+  gitlab_get_file: tool5({
+    description: `Get the contents of a file from a repository.
+Supports fetching files from any branch, tag, or commit SHA.
+If ref is not specified, uses the project's default branch.
+Note: Invalid refs will result in a 404 error from the GitLab API.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      file_path: z5.string().describe("Path to the file in the repository"),
+      ref: z5.string().optional().describe(
+        `Branch name, tag, or commit SHA to fetch the file from. Supports full or short commit SHAs. If omitted, uses the project's default branch (e.g., "main" or "master").`
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      return client.getFile(args.project_id, args.file_path, args.ref);
+    }
+  }),
+  gitlab_get_commit: tool5({
+    description: `Get a single commit with full details.
+Returns commit metadata including author, message, stats, and parent commits.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      sha: z5.string().describe("The commit SHA")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const commit = await client.getCommit(args.project_id, args.sha);
+      return JSON.stringify(commit, null, 2);
+    }
+  }),
+  gitlab_list_commits: tool5({
+    description: `List commits in a repository. Can filter by branch/ref and path.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      ref: z5.string().optional().describe("Branch or tag name"),
+      path: z5.string().optional().describe("File or directory path to filter commits"),
+      since: z5.string().optional().describe("Only commits after this date (ISO 8601 format)"),
+      until: z5.string().optional().describe("Only commits before this date (ISO 8601 format)"),
+      limit: z5.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const commits = await client.listCommits(args.project_id, {
+        ref: args.ref,
+        path: args.path,
+        since: args.since,
+        until: args.until,
+        limit: args.limit
+      });
+      return JSON.stringify(commits, null, 2);
+    }
+  }),
+  gitlab_get_commit_diff: tool5({
+    description: `Get the diff for a specific commit.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      sha: z5.string().describe("The commit SHA")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const diff = await client.getCommitDiff(args.project_id, args.sha);
+      return JSON.stringify(diff, null, 2);
+    }
+  }),
+  gitlab_list_repository_tree: tool5({
+    description: `List files and directories in a repository.
+Returns the tree structure of the repository at a given path and ref.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      path: z5.string().optional().describe("Path inside repository (default: root)"),
+      ref: z5.string().optional().describe("Branch, tag, or commit SHA (default: default branch)"),
+      recursive: z5.boolean().optional().describe("Get recursive tree (default: false)"),
+      per_page: z5.number().optional().describe("Number of results per page (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const tree = await client.listRepositoryTree(args.project_id, {
+        path: args.path,
+        ref: args.ref,
+        recursive: args.recursive,
+        per_page: args.per_page
+      });
+      return JSON.stringify(tree, null, 2);
+    }
+  }),
+  gitlab_list_branches: tool5({
+    description: `List branches in a repository.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      search: z5.string().optional().describe("Search branches by name")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const branches = await client.listBranches(args.project_id, args.search);
+      return JSON.stringify(branches, null, 2);
+    }
+  }),
+  gitlab_get_commit_comments: tool5({
+    description: `Get all comments on a specific commit.
+Returns all comments (notes) that have been added to a commit, including line-specific comments.
+This is different from discussions - it returns individual comments in a flat structure.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      sha: z5.string().describe("The commit SHA")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const comments = await client.getCommitComments(args.project_id, args.sha);
+      return JSON.stringify(comments, null, 2);
+    }
+  })
+};
+
+// src/tools/search.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
+var z6 = tool6.schema;
+var GENERIC_SEARCH_SCOPES = ["projects", "issues", "merge_requests", "blobs"];
+var SPECIALIZED_SCOPES = [
+  "milestones",
+  "users",
+  "commits",
+  "notes",
+  "wiki_blobs",
+  "group_projects"
+];
+var ALL_SCOPES = [...GENERIC_SEARCH_SCOPES, ...SPECIALIZED_SCOPES];
+var REF_SUPPORTED_SCOPES = ["commits", "wiki_blobs"];
+var STATE_SUPPORTED_SCOPES = ["milestones"];
+function validationError2(param, scope) {
+  return new Error(`Missing required parameter: '${param}' is required for scope '${scope}'`);
+}
+function invalidParamError(param, validScopes) {
+  return new Error(
+    `Invalid parameter: '${param}' is only valid for scopes: ${validScopes.join(", ")}`
+  );
+}
+function validateSearchParams(scope, args) {
+  switch (scope) {
+    case "notes":
+      if (!args.project_id) throw validationError2("project_id", scope);
+      break;
+    case "group_projects":
+      if (!args.group_id) throw validationError2("group_id", scope);
+      break;
+  }
+  if (args.ref && !REF_SUPPORTED_SCOPES.includes(scope)) {
+    throw invalidParamError("ref", REF_SUPPORTED_SCOPES);
+  }
+  if (args.state && !STATE_SUPPORTED_SCOPES.includes(scope)) {
+    throw invalidParamError("state", STATE_SUPPORTED_SCOPES);
+  }
+}
+var searchTools = {
+  /**
+   * Unified search across all GitLab resources
+   *
+   * @example
+   * // Search for issues in a project
+   * gitlab_search({ scope: "issues", search: "bug", project_id: "my-group/project" })
+   *
+   * @example
+   * // Search commits on specific branch
+   * gitlab_search({ scope: "commits", search: "fix", ref: "main" })
+   *
+   * @example
+   * // Search for projects within a group
+   * gitlab_search({ scope: "group_projects", group_id: "gitlab-org", search: "runner" })
+   *
+   * @example
+   * // Search notes/comments in a project
+   * gitlab_search({ scope: "notes", search: "LGTM", project_id: "my-group/project" })
+   */
+  gitlab_search: tool6({
+    description: `Search across GitLab for various resources with scope-specific options.
+
+Scopes and their requirements:
+- projects: Search projects by name/description
+- issues: Search issues by title/description
+- merge_requests: Search MRs by title/description
+- milestones: Search milestones (supports state filter)
+- users: Search users by name/email
+- blobs: Search file content (code search)
+- commits: Search commits by message/author/SHA (supports ref filter)
+- notes: Search comments/notes (requires project_id)
+- wiki_blobs: Search wiki content (supports ref filter)
+- group_projects: Search projects within a group (requires group_id)
+
+Examples:
+- Issues: scope="issues", search="bug", project_id="my-group/my-project"
+- Code: scope="blobs", search="function calculateTotal"
+- Commits: scope="commits", search="fix login", ref="main"
+- Group projects: scope="group_projects", group_id="gitlab-org", search="runner"
+- Notes: scope="notes", search="LGTM", project_id="my-group/my-project"`,
+    args: {
+      scope: z6.enum([
+        "projects",
+        "issues",
+        "merge_requests",
+        "milestones",
+        "users",
+        "blobs",
+        "commits",
+        "notes",
+        "wiki_blobs",
+        "group_projects"
+      ]).describe("The type of resource to search"),
+      search: z6.string().describe("The search query"),
+      // Context parameters
+      project_id: z6.string().optional().describe("Limit search to a specific project. Required for notes scope"),
+      group_id: z6.string().optional().describe("Group ID or path. Required for group_projects scope"),
+      // Common options
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)"),
+      order_by: z6.enum(["created_at"]).optional().describe(
+        "Order results by field (for milestones, users, commits, notes, wiki_blobs, group_projects)"
+      ),
+      sort: z6.enum(["asc", "desc"]).optional().describe("Sort order (for milestones, users, commits, notes, wiki_blobs, group_projects)"),
+      // Scope-specific options
+      ref: z6.string().optional().describe("Branch or tag name (for commits, wiki_blobs scopes)"),
+      state: z6.enum(["active", "closed", "all"]).optional().describe("Filter by state (for milestones scope)")
+    },
+    execute: async (args, _ctx) => {
+      validateSearchParams(args.scope, {
+        project_id: args.project_id,
+        group_id: args.group_id,
+        ref: args.ref,
+        state: args.state
+      });
+      const client = getGitLabClient();
+      const commonOptions = {
+        order_by: args.order_by,
+        sort: args.sort,
+        limit: args.limit
+      };
+      switch (args.scope) {
+        // Generic search API scopes
+        case "projects":
+        case "issues":
+        case "merge_requests":
+        case "blobs":
+          return JSON.stringify(
+            await client.search(args.scope, args.search, args.project_id, args.limit),
+            null,
+            2
+          );
+        // Specialized scopes with dedicated client methods
+        case "milestones":
+          return JSON.stringify(
+            await client.searchMilestones(args.search, args.project_id, {
+              ...commonOptions,
+              state: args.state
+            }),
+            null,
+            2
+          );
+        case "users":
+          return JSON.stringify(
+            await client.searchUsers(args.search, args.project_id, commonOptions),
+            null,
+            2
+          );
+        case "commits":
+          return JSON.stringify(
+            await client.searchCommits(args.search, args.project_id, {
+              ...commonOptions,
+              ref: args.ref
+            }),
+            null,
+            2
+          );
+        case "notes":
+          return JSON.stringify(
+            await client.searchNotes(args.search, args.project_id, commonOptions),
+            null,
+            2
+          );
+        case "wiki_blobs":
+          return JSON.stringify(
+            await client.searchWikiBlobs(args.search, args.project_id, {
+              ...commonOptions,
+              ref: args.ref
+            }),
+            null,
+            2
+          );
+        case "group_projects":
+          return JSON.stringify(
+            await client.searchGroupProjects(args.group_id, args.search, commonOptions),
+            null,
+            2
+          );
+        default:
+          throw new Error(
+            `Invalid scope '${args.scope}'. Must be one of: ${ALL_SCOPES.join(", ")}`
+          );
+      }
+    }
+  }),
+  /**
+   * Search GitLab official documentation
+   * Separate tool because it uses a completely different API (docs.gitlab.com)
+   */
+  gitlab_documentation_search: tool6({
+    description: `Search GitLab official documentation at docs.gitlab.com.
+Returns relevant documentation pages matching the search query.
+
+Useful for:
+- Finding GitLab feature documentation
+- Learning about GitLab APIs and integrations
+- Discovering best practices and guides
+- Troubleshooting GitLab issues
+
+Note: This searches the public GitLab documentation site, not your instance's documentation.`,
+    args: {
+      search: z6.string().describe("The search query (documentation topic or keyword)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 10)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.searchDocumentation(args.search, args.limit);
+      return JSON.stringify(results, null, 2);
+    }
+  })
+};
+
+// src/tools/projects.ts
+import { tool as tool7 } from "@opencode-ai/plugin";
+var z7 = tool7.schema;
+var projectTools = {
+  gitlab_get_project: tool7({
+    description: `Get details of a specific project.`,
+    args: {
+      project_id: z7.string().describe('The project ID or URL-encoded path (e.g., "gitlab-org/gitlab")')
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const project = await client.getProject(args.project_id);
+      return JSON.stringify(project, null, 2);
+    }
+  }),
+  gitlab_list_project_members: tool7({
+    description: `List members of a project.`,
+    args: {
+      project_id: z7.string().describe("The project ID or URL-encoded path")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const members = await client.listProjectMembers(args.project_id);
+      return JSON.stringify(members, null, 2);
+    }
+  })
+};
+
+// src/tools/users.ts
+import { tool as tool8 } from "@opencode-ai/plugin";
+var z8 = tool8.schema;
+var userTools = {
+  gitlab_get_current_user: tool8({
+    description: `Get current user information.
+Returns details about the authenticated user including username, email, and permissions.`,
+    args: {},
+    execute: async (_args, _ctx) => {
+      const client = getGitLabClient();
+      const user = await client.getCurrentUser();
+      return JSON.stringify(user, null, 2);
+    }
+  }),
+  gitlab_get_user: tool8({
+    description: `Get a user by their ID.
+Returns user details including username, name, state, and profile information.`,
+    args: {
+      user_id: z8.number().describe("The user ID")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const user = await client.getUser(args.user_id);
+      return JSON.stringify(user, null, 2);
+    }
+  }),
+  gitlab_get_user_by_username: tool8({
+    description: `Find a user by their username.
+Returns user details including ID, name, state, and profile information.
+Useful for looking up a user's ID when you only know their username.`,
+    args: {
+      username: z8.string().describe("The username to look up (without @ prefix)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const username = args.username.replace(/^@/, "");
+      const users = await client.getUserByUsername(username);
+      if (users.length === 0) {
+        return JSON.stringify({ error: `No user found with username: ${username}` });
+      }
+      if (users.length > 1) {
+        return JSON.stringify(
+          {
+            warning: `Multiple users found for username: ${username}`,
+            users
+          },
+          null,
+          2
+        );
+      }
+      return JSON.stringify(users[0], null, 2);
+    }
+  }),
+  gitlab_get_user_status: tool8({
+    description: `Get a user's status including availability.
+Returns the user's status emoji, message, and availability (e.g., "busy").
+Useful for checking if someone is available before requesting a review.`,
+    args: {
+      user_id: z8.number().describe("The user ID")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const status = await client.getUserStatus(args.user_id);
+      return JSON.stringify(status, null, 2);
+    }
+  })
+};
+
+// src/tools/security.ts
+import { tool as tool9 } from "@opencode-ai/plugin";
+var z9 = tool9.schema;
+var securityTools = {
+  gitlab_list_vulnerabilities: tool9({
+    description: `List persisted vulnerabilities for a project.
+Returns security vulnerabilities detected in the project.`,
+    args: {
+      project_id: z9.string().describe("The project ID or URL-encoded path"),
+      state: z9.enum(["detected", "confirmed", "dismissed", "resolved"]).optional().describe("Filter by vulnerability state"),
+      severity: z9.enum(["undefined", "info", "unknown", "low", "medium", "high", "critical"]).optional().describe("Filter by severity level"),
+      report_type: z9.enum([
+        "sast",
+        "dast",
+        "dependency_scanning",
+        "container_scanning",
+        "secret_detection",
+        "coverage_fuzzing",
+        "api_fuzzing"
+      ]).optional().describe("Filter by report type"),
+      limit: z9.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const vulnerabilities = await client.listVulnerabilities(args.project_id, {
+        state: args.state,
+        severity: args.severity,
+        report_type: args.report_type,
+        limit: args.limit
+      });
+      return JSON.stringify(vulnerabilities, null, 2);
+    }
+  }),
+  gitlab_get_vulnerability_details: tool9({
+    description: `Get details for a specific vulnerability.
+Returns full information about a security vulnerability including description, location, and remediation.`,
+    args: {
+      project_id: z9.string().describe("The project ID or URL-encoded path"),
+      vulnerability_id: z9.number().describe("The ID of the vulnerability")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const vulnerability = await client.getVulnerabilityDetails(
+        args.project_id,
+        args.vulnerability_id
+      );
+      return JSON.stringify(vulnerability, null, 2);
+    }
+  }),
+  gitlab_create_vulnerability_issue: tool9({
+    description: `Create a new issue linked to one or more security vulnerabilities.
+This creates an issue in the project and automatically links it to the specified vulnerabilities.
+Requires Developer role or higher.`,
+    args: {
+      project_path: z9.string().describe('Full path of the project (e.g., "group/project" or "group/subgroup/project")'),
+      vulnerability_ids: z9.array(z9.string()).describe(
+        'Array of vulnerability IDs in format "gid://gitlab/Vulnerability/{id}". Get these from gitlab_list_vulnerabilities.'
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const issue = await client.createVulnerabilityIssue(
+        args.project_path,
+        args.vulnerability_ids
+      );
+      return JSON.stringify(issue, null, 2);
+    }
+  }),
+  gitlab_dismiss_vulnerability: tool9({
+    description: `Dismiss a security vulnerability with a reason.
+Use this when a vulnerability is not applicable, is a false positive, or has been mitigated.
+Requires Developer role or higher.`,
+    args: {
+      vulnerability_id: z9.string().describe(
+        'Vulnerability ID in format "gid://gitlab/Vulnerability/{id}". Get this from gitlab_list_vulnerabilities.'
+      ),
+      reason: z9.enum([
+        "ACCEPTABLE_RISK",
+        "FALSE_POSITIVE",
+        "MITIGATING_CONTROL",
+        "USED_IN_TESTS",
+        "NOT_APPLICABLE"
+      ]).describe("Reason for dismissing the vulnerability"),
+      comment: z9.string().optional().describe("Optional comment explaining the dismissal")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const vulnerability = await client.dismissVulnerability(
+        args.vulnerability_id,
+        args.reason,
+        args.comment
+      );
+      return JSON.stringify(vulnerability, null, 2);
+    }
+  }),
+  gitlab_confirm_vulnerability: tool9({
+    description: `Confirm a security vulnerability.
+Use this to acknowledge that a vulnerability is valid and needs attention.
+Requires Developer role or higher.`,
+    args: {
+      vulnerability_id: z9.string().describe(
+        'Vulnerability ID in format "gid://gitlab/Vulnerability/{id}". Get this from gitlab_list_vulnerabilities.'
+      ),
+      comment: z9.string().optional().describe("Optional comment about the confirmation")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const vulnerability = await client.confirmVulnerability(args.vulnerability_id, args.comment);
+      return JSON.stringify(vulnerability, null, 2);
+    }
+  }),
+  gitlab_revert_vulnerability_to_detected: tool9({
+    description: `Revert a vulnerability back to detected state.
+Use this to undo a previous confirmation or dismissal.
+Requires Developer role or higher.`,
+    args: {
+      vulnerability_id: z9.string().describe(
+        'Vulnerability ID in format "gid://gitlab/Vulnerability/{id}". Get this from gitlab_list_vulnerabilities.'
+      ),
+      comment: z9.string().optional().describe("Optional comment about reverting the state")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const vulnerability = await client.revertVulnerability(args.vulnerability_id, args.comment);
+      return JSON.stringify(vulnerability, null, 2);
+    }
+  }),
+  gitlab_update_vulnerability_severity: tool9({
+    description: `Update the severity level of one or more vulnerabilities.
+Use this to adjust the severity rating based on your assessment.
+Requires Developer role or higher.`,
+    args: {
+      vulnerability_ids: z9.array(z9.string()).describe(
+        'Array of vulnerability IDs in format "gid://gitlab/Vulnerability/{id}". Get these from gitlab_list_vulnerabilities.'
+      ),
+      severity: z9.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO", "UNKNOWN"]).describe("New severity level for the vulnerabilities"),
+      comment: z9.string().describe("Comment explaining the severity change (required)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const vulnerabilities = await client.updateVulnerabilitySeverity(
+        args.vulnerability_ids,
+        args.severity,
+        args.comment
+      );
+      return JSON.stringify(vulnerabilities, null, 2);
+    }
+  }),
+  gitlab_link_vulnerability_to_issue: tool9({
+    description: `Link an existing issue to one or more vulnerabilities.
+Use this to associate vulnerabilities with an existing issue for tracking.
+Requires Developer role or higher.`,
+    args: {
+      issue_id: z9.string().describe(
+        'Issue ID in format "gid://gitlab/Issue/{id}". You can construct this from the issue IID.'
+      ),
+      vulnerability_ids: z9.array(z9.string()).describe(
+        'Array of vulnerability IDs in format "gid://gitlab/Vulnerability/{id}". Get these from gitlab_list_vulnerabilities.'
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const issue = await client.linkVulnerabilityToIssue(args.issue_id, args.vulnerability_ids);
+      return JSON.stringify(issue, null, 2);
+    }
+  })
+};
+
+// src/tools/todos.ts
+import { tool as tool10 } from "@opencode-ai/plugin";
+var z10 = tool10.schema;
+var todoTools = {
+  gitlab_list_todos: tool10({
+    description: `List TODO items for the current user using GraphQL API with pagination support.
+Returns a list of pending or done TODO items assigned to the authenticated user.
+TODOs are created when you are assigned to an issue/MR, mentioned in a comment, or when someone requests your review.
+
+The response includes pagination information (pageInfo) with cursors for fetching additional pages.
+Use 'after' with the 'endCursor' from pageInfo to get the next page.
+Use 'before' with the 'startCursor' from pageInfo to get the previous page.`,
+    args: {
+      action: z10.enum([
+        "assigned",
+        "mentioned",
+        "build_failed",
+        "marked",
+        "approval_required",
+        "unmergeable",
+        "directly_addressed",
+        "merge_train_removed",
+        "review_requested"
+      ]).optional().describe("Filter by action type"),
+      author_id: z10.number().optional().describe("Filter by author ID"),
+      project_id: z10.string().optional().describe("Filter by project ID or path"),
+      group_id: z10.string().optional().describe("Filter by group ID"),
+      state: z10.enum(["pending", "done"]).optional().describe("Filter by state (default: pending)"),
+      type: z10.enum(["Issue", "MergeRequest", "DesignManagement::Design", "Alert", "Epic", "Commit"]).optional().describe("Filter by target type"),
+      first: z10.number().optional().describe("Number of items to return from the beginning (default: 20, max: 100)"),
+      after: z10.string().optional().describe("Cursor for forward pagination - use endCursor from previous response"),
+      last: z10.number().optional().describe("Number of items to return from the end (for backward pagination)"),
+      before: z10.string().optional().describe("Cursor for backward pagination - use startCursor from previous response")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const result = await client.listTodos({
+        action: args.action,
+        author_id: args.author_id,
+        project_id: args.project_id,
+        group_id: args.group_id,
+        state: args.state,
+        type: args.type,
+        first: args.first,
+        after: args.after,
+        last: args.last,
+        before: args.before
+      });
+      return JSON.stringify(result, null, 2);
+    }
+  }),
+  gitlab_mark_todo_done: tool10({
+    description: `Mark TODO items as done.
+
+Actions:
+- one: Mark a specific TODO item as done (requires todo_id)
+- all: Mark all pending TODO items as done
+
+Examples:
+- Mark one: action="one", todo_id=123
+- Mark all: action="all"`,
+    args: {
+      action: z10.enum(["one", "all"]).describe('Action to perform: "one" for single TODO, "all" for all TODOs'),
+      todo_id: z10.number().optional().describe('The ID of the TODO item (required for action="one")')
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      switch (args.action) {
+        case "one": {
+          if (args.todo_id === void 0) {
+            return JSON.stringify({ error: 'todo_id is required when action is "one"' }, null, 2);
+          }
+          const result = await client.markTodoAsDone(args.todo_id);
+          if (!result.success) {
+            return JSON.stringify(
+              {
+                success: false,
+                message: result.message
+              },
+              null,
+              2
+            );
+          }
+          return JSON.stringify(
+            {
+              success: true,
+              todo: result.todo
+            },
+            null,
+            2
+          );
+        }
+        case "all": {
+          const result = await client.markAllTodosAsDone();
+          return JSON.stringify(result, null, 2);
+        }
+      }
+    }
+  }),
+  gitlab_get_todo_count: tool10({
+    description: `Get the count of pending TODO items.
+Returns the total number of pending TODOs for the current user.`,
+    args: {},
+    execute: async (_args, _ctx) => {
+      const client = getGitLabClient();
+      const count = await client.getTodoCount();
+      return JSON.stringify(count, null, 2);
+    }
+  })
+};
+
+// src/tools/wikis.ts
+import { tool as tool11 } from "@opencode-ai/plugin";
+var z11 = tool11.schema;
+var wikiTools = {
+  gitlab_get_wiki_page: tool11({
+    description: `Get a wiki page with its content.
+Returns the wiki page content and metadata.`,
+    args: {
+      project_id: z11.string().describe("The project ID or URL-encoded path"),
+      slug: z11.string().describe("The slug (URL-friendly name) of the wiki page")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const page = await client.getWikiPage(args.project_id, args.slug);
+      return JSON.stringify(page, null, 2);
+    }
+  })
+};
+
+// src/tools/work-items.ts
+import { tool as tool12 } from "@opencode-ai/plugin";
+var z12 = tool12.schema;
+var workItemTools = {
+  gitlab_get_work_item: tool12({
+    description: `Get a single work item (issue, epic, task, etc.).
+Work items are the new unified model for issues, epics, tasks, and other work tracking items in GitLab.`,
+    args: {
+      project_id: z12.string().describe("The project ID or URL-encoded path"),
+      work_item_id: z12.number().describe("The ID of the work item")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const workItem = await client.getWorkItem(args.project_id, args.work_item_id);
+      return JSON.stringify(workItem, null, 2);
+    }
+  }),
+  gitlab_list_work_items: tool12({
+    description: `List work items in a project or group.
+Work items include issues, epics, tasks, and other work tracking items.`,
+    args: {
+      project_id: z12.string().optional().describe("The project ID or URL-encoded path"),
+      group_id: z12.string().optional().describe("The group ID or URL-encoded path"),
+      state: z12.enum(["opened", "closed", "all"]).optional().describe("Filter by state (default: opened)"),
+      search: z12.string().optional().describe("Search work items by title or description"),
+      labels: z12.string().optional().describe("Comma-separated list of labels to filter by"),
+      work_item_type: z12.string().optional().describe("Filter by work item type (e.g., 'Issue', 'Epic', 'Task')"),
+      limit: z12.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const workItems = await client.listWorkItems({
+        projectId: args.project_id,
+        groupId: args.group_id,
+        state: args.state,
+        search: args.search,
+        labels: args.labels,
+        work_item_type: args.work_item_type,
+        limit: args.limit
+      });
+      return JSON.stringify(workItems, null, 2);
+    }
+  }),
+  gitlab_get_work_item_notes: tool12({
+    description: `Get all comments for a work item.
+Returns all notes/comments on the work item in chronological order.`,
+    args: {
+      project_id: z12.string().describe("The project ID or URL-encoded path"),
+      work_item_id: z12.number().describe("The ID of the work item")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const notes = await client.getWorkItemNotes(args.project_id, args.work_item_id);
+      return JSON.stringify(notes, null, 2);
+    }
+  }),
+  gitlab_create_work_item: tool12({
+    description: `Create a new work item (issue, task, etc.).
+Work items are the new unified model for issues, epics, tasks, and other work tracking items.`,
+    args: {
+      project_id: z12.string().describe("The project ID or URL-encoded path"),
+      title: z12.string().describe("The title of the work item"),
+      work_item_type_id: z12.number().describe("The ID of the work item type (e.g., 1 for Issue, 2 for Task)"),
+      description: z12.string().optional().describe("The description of the work item (supports Markdown)"),
+      labels: z12.array(z12.string()).optional().describe("Array of label names"),
+      assignee_ids: z12.array(z12.number()).optional().describe("Array of user IDs to assign")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const workItem = await client.createWorkItem(args.project_id, {
+        title: args.title,
+        work_item_type_id: args.work_item_type_id,
+        description: args.description,
+        labels: args.labels,
+        assignee_ids: args.assignee_ids
+      });
+      return JSON.stringify(workItem, null, 2);
+    }
+  }),
+  gitlab_update_work_item: tool12({
+    description: `Update an existing work item.
+Can update title, description, state, labels, and assignees.`,
+    args: {
+      project_id: z12.string().describe("The project ID or URL-encoded path"),
+      work_item_id: z12.number().describe("The ID of the work item"),
+      title: z12.string().optional().describe("The new title"),
+      description: z12.string().optional().describe("The new description (supports Markdown)"),
+      state_event: z12.enum(["close", "reopen"]).optional().describe("Change the state (close or reopen)"),
+      labels: z12.array(z12.string()).optional().describe("Array of label names"),
+      assignee_ids: z12.array(z12.number()).optional().describe("Array of user IDs to assign")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const workItem = await client.updateWorkItem(args.project_id, args.work_item_id, {
+        title: args.title,
+        description: args.description,
+        state_event: args.state_event,
+        labels: args.labels,
+        assignee_ids: args.assignee_ids
+      });
+      return JSON.stringify(workItem, null, 2);
+    }
+  }),
+  gitlab_create_work_item_note: tool12({
+    description: `Create a comment on a work item.`,
+    args: {
+      project_id: z12.string().describe("The project ID or URL-encoded path"),
+      work_item_id: z12.number().describe("The ID of the work item"),
+      body: z12.string().describe("The content of the note/comment (supports Markdown)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const note = await client.createWorkItemNote(args.project_id, args.work_item_id, args.body);
+      return JSON.stringify(note, null, 2);
+    }
+  })
+};
+
+// src/tools/discussions-unified.ts
+import { tool as tool13 } from "@opencode-ai/plugin";
+var z13 = tool13.schema;
+function normalizeBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function filterDiscussionsByResolved(result, resolved) {
+  const normalizedResolved = normalizeBoolean(resolved);
+  if (normalizedResolved === void 0) {
+    return result;
+  }
+  return {
+    discussions: {
+      ...result.discussions,
+      nodes: result.discussions.nodes.filter(
+        (d) => d.resolvable && d.resolved === normalizedResolved
+      )
+    }
+  };
+}
+var positionSchema = z13.object({
+  base_sha: z13.string().describe("SHA of the base commit"),
+  start_sha: z13.string().describe("SHA of the start commit"),
+  head_sha: z13.string().describe("SHA of the head commit"),
+  position_type: z13.enum(["text", "image"]).describe("Type of position"),
+  old_path: z13.string().optional().describe("Path of the file before changes"),
+  new_path: z13.string().optional().describe("Path of the file after changes"),
+  old_line: z13.number().optional().describe("Line number in the old version"),
+  new_line: z13.number().optional().describe("Line number in the new version")
+});
+function validateResourceParams(resourceType, args) {
+  switch (resourceType) {
+    case "merge_request":
+    case "issue":
+      if (!args.project_id) throw new Error(`project_id is required for ${resourceType}`);
+      if (args.iid == null) throw new Error(`iid is required for ${resourceType}`);
+      break;
+    case "epic":
+      if (!args.group_id) throw new Error("group_id is required for epic");
+      if (args.iid == null) throw new Error("iid is required for epic");
+      break;
+    case "commit":
+      if (!args.project_id) throw new Error("project_id is required for commit");
+      if (!args.sha) throw new Error("sha is required for commit");
+      break;
+    case "snippet":
+      if (!args.project_id) throw new Error("project_id is required for snippet");
+      if (args.snippet_id == null) throw new Error("snippet_id is required for snippet");
+      break;
+  }
+}
+var discussionsUnifiedTools = {
+  /**
+   * List discussions for any GitLab resource type
+   */
+  gitlab_list_discussions: tool13({
+    description: `List discussions (comment threads) on any GitLab resource.
+Supports: merge_requests, issues, epics, commits, snippets.
+
+Returns discussion threads with nested notes. Each discussion contains 
+a 'notes' array with individual comments.
+
+For pagination, use 'after' with the 'endCursor' from pageInfo to get the next page.
+
+Examples:
+- MR: resource_type="merge_request", project_id="group/project", iid=123
+- Issue: resource_type="issue", project_id="group/project", iid=456  
+- Epic: resource_type="epic", group_id="my-group", iid=1
+- Commit: resource_type="commit", project_id="group/project", sha="abc123"
+- Snippet: resource_type="snippet", project_id="group/project", snippet_id=789`,
+    args: {
+      resource_type: z13.enum(["merge_request", "issue", "epic", "commit", "snippet"]).describe("Type of GitLab resource"),
+      project_id: z13.string().optional().describe("Project ID or path. Required for merge_request, issue, commit, snippet"),
+      group_id: z13.string().optional().describe("Group ID or path. Required for epic"),
+      iid: z13.number().optional().describe("Internal ID of the resource (for merge_request, issue, epic)"),
+      sha: z13.string().optional().describe("Commit SHA (required for commit)"),
+      snippet_id: z13.number().optional().describe("Snippet ID (required for snippet)"),
+      // Filtering
+      resolved: z13.boolean().optional().describe(
+        "Filter by resolved status: true for resolved, false for unresolved. Only returns resolvable discussions (excludes system notes). Client-side filtering."
+      ),
+      // Pagination
+      first: z13.number().optional().describe("Number of items to return (default: 20)"),
+      after: z13.string().optional().describe("Cursor for pagination - use endCursor from previous response"),
+      before: z13.string().optional().describe("Cursor for backward pagination"),
+      last: z13.number().optional().describe("Number of items from the end")
+    },
+    execute: async (args, _ctx) => {
+      validateResourceParams(args.resource_type, args);
+      const client = getGitLabClient();
+      const paginationOptions = {
+        first: args.first,
+        after: args.after,
+        before: args.before,
+        last: args.last
+      };
+      let result;
+      switch (args.resource_type) {
+        case "merge_request":
+          result = await client.listMrDiscussions(args.project_id, args.iid, paginationOptions);
+          break;
+        case "issue":
+          result = await client.listIssueDiscussions(
+            args.project_id,
+            args.iid,
+            paginationOptions
+          );
+          break;
+        case "epic":
+          result = await client.listEpicDiscussions(args.group_id, args.iid, paginationOptions);
+          break;
+        case "commit":
+          return JSON.stringify(
+            await client.listCommitDiscussions(args.project_id, args.sha),
+            null,
+            2
+          );
+        case "snippet":
+          result = await client.listSnippetDiscussions(
+            args.project_id,
+            args.snippet_id,
+            paginationOptions
+          );
+          break;
+        default:
+          throw new Error(`Unsupported resource type: ${args.resource_type}`);
+      }
+      const filteredResult = filterDiscussionsByResolved(result, args.resolved);
+      return JSON.stringify(filteredResult, null, 2);
+    }
+  }),
+  /**
+   * Get a specific discussion thread from any GitLab resource
+   */
+  gitlab_get_discussion: tool13({
+    description: `Get a specific discussion thread with all its replies.
+Returns the discussion with its 'notes' array containing all comments.
+
+Use this to get full context of a specific conversation.
+
+Required parameters vary by resource type:
+- merge_request: project_id, iid, discussion_id
+- issue: project_id, iid, discussion_id  
+- epic: group_id, iid, discussion_id
+- commit: project_id, sha, discussion_id
+- snippet: project_id, snippet_id, discussion_id`,
+    args: {
+      resource_type: z13.enum(["merge_request", "issue", "epic", "commit", "snippet"]).describe("Type of GitLab resource"),
+      discussion_id: z13.string().describe("The ID of the discussion thread"),
+      project_id: z13.string().optional().describe("Project ID or path"),
+      group_id: z13.string().optional().describe("Group ID or path (for epic)"),
+      iid: z13.number().optional().describe("Internal ID (for merge_request, issue, epic)"),
+      sha: z13.string().optional().describe("Commit SHA (for commit)"),
+      snippet_id: z13.number().optional().describe("Snippet ID (for snippet)")
+    },
+    execute: async (args, _ctx) => {
+      validateResourceParams(args.resource_type, args);
+      const client = getGitLabClient();
+      switch (args.resource_type) {
+        case "merge_request":
+          return JSON.stringify(
+            await client.getMrDiscussion(args.project_id, args.iid, args.discussion_id),
+            null,
+            2
+          );
+        case "issue":
+          return JSON.stringify(
+            await client.getIssueDiscussion(args.project_id, args.iid, args.discussion_id),
+            null,
+            2
+          );
+        case "epic":
+          return JSON.stringify(
+            await client.getEpicDiscussion(args.group_id, args.iid, args.discussion_id),
+            null,
+            2
+          );
+        case "commit":
+          return JSON.stringify(
+            await client.getCommitDiscussion(args.project_id, args.sha, args.discussion_id),
+            null,
+            2
+          );
+        case "snippet":
+          return JSON.stringify(
+            await client.getSnippetDiscussion(
+              args.project_id,
+              args.snippet_id,
+              args.discussion_id
+            ),
+            null,
+            2
+          );
+        default:
+          throw new Error(`Unsupported resource type: ${args.resource_type}`);
+      }
+    }
+  }),
+  /**
+   * Create a new discussion thread or reply to an existing one
+   */
+  gitlab_create_discussion: tool13({
+    description: `Create a new discussion thread or reply to an existing one.
+
+REPLYING TO EXISTING THREADS:
+To reply to an existing discussion, provide the discussion_id parameter.
+This is the recommended way to reply in-thread rather than creating a standalone comment.
+
+STARTING A NEW DISCUSSION:
+Omit discussion_id to create a new thread. For code-specific comments on MRs/commits, provide position information.
+
+Examples:
+- Reply to thread: resource_type="merge_request", project_id="group/project", iid=123, discussion_id="abc123def", body="Thanks for the feedback!"
+- New comment: resource_type="merge_request", project_id="group/project", iid=123, body="General comment"
+- Code comment: resource_type="merge_request", project_id="group/project", iid=123, body="...", position={base_sha, head_sha, new_path, new_line, ...}`,
+    args: {
+      resource_type: z13.enum(["merge_request", "issue", "epic", "commit", "snippet"]).describe("Type of GitLab resource"),
+      body: z13.string().describe("The comment text (Markdown supported)"),
+      project_id: z13.string().optional().describe("Project ID or path"),
+      group_id: z13.string().optional().describe("Group ID or path (for epic)"),
+      iid: z13.number().optional().describe("Internal ID (for merge_request, issue, epic)"),
+      sha: z13.string().optional().describe("Commit SHA (for commit)"),
+      snippet_id: z13.number().optional().describe("Snippet ID (for snippet)"),
+      discussion_id: z13.string().optional().describe("If provided, replies to existing discussion. If omitted, creates new thread"),
+      position: positionSchema.optional().describe("Position for code-specific comments (MR/commit only)")
+    },
+    execute: async (args, _ctx) => {
+      validateResourceParams(args.resource_type, args);
+      const client = getGitLabClient();
+      if (args.discussion_id) {
+        const note = await client.replyToDiscussion(
+          args.resource_type,
+          {
+            projectId: args.project_id,
+            groupId: args.group_id,
+            iid: args.iid,
+            sha: args.sha,
+            snippetId: args.snippet_id
+          },
+          args.discussion_id,
+          args.body
+        );
+        return JSON.stringify(note, null, 2);
+      }
+      switch (args.resource_type) {
+        case "merge_request":
+          return JSON.stringify(
+            await client.createMrDiscussion(args.project_id, args.iid, args.body, args.position),
+            null,
+            2
+          );
+        case "issue":
+          return JSON.stringify(
+            await client.createIssueNote(args.project_id, args.iid, args.body),
+            null,
+            2
+          );
+        case "epic":
+          return JSON.stringify(
+            await client.createEpicNote(args.group_id, args.iid, args.body),
+            null,
+            2
+          );
+        case "commit":
+          return JSON.stringify(
+            await client.createCommitDiscussion(
+              args.project_id,
+              args.sha,
+              args.body,
+              args.position
+            ),
+            null,
+            2
+          );
+        case "snippet":
+          return JSON.stringify(
+            await client.createSnippetDiscussion(args.project_id, args.snippet_id, args.body),
+            null,
+            2
+          );
+        default:
+          throw new Error(`Unsupported resource type: ${args.resource_type}`);
+      }
+    }
+  }),
+  /**
+   * Resolve or unresolve a discussion thread
+   */
+  gitlab_resolve_discussion: tool13({
+    description: `Mark a discussion thread as resolved or unresolve it.
+Only works for resolvable discussions (MRs and issues only).
+
+Uses GraphQL API which handles all discussion types including outdated discussions
+(those with resolved: null) that the REST API cannot handle.
+
+Use after addressing feedback to indicate the discussion is complete.`,
+    args: {
+      resource_type: z13.enum(["merge_request", "issue"]).describe("Type of resource (only MR and issue discussions can be resolved)"),
+      action: z13.enum(["resolve", "unresolve"]).describe("Whether to resolve or unresolve"),
+      discussion_id: z13.string().describe("The ID of the discussion thread"),
+      project_id: z13.string().describe("Project ID or path"),
+      iid: z13.number().describe("Internal ID of the MR or issue")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const resolve2 = args.action === "resolve";
+      return JSON.stringify(
+        await client.toggleDiscussionResolved(args.discussion_id, resolve2),
+        null,
+        2
+      );
+    }
+  })
+};
+
+// src/tools/notes-unified.ts
+import { tool as tool14 } from "@opencode-ai/plugin";
+var z14 = tool14.schema;
+function normalizeBoolean2(value) {
+  if (typeof value === "boolean") return value;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function filterNotesByResolved(result, resolved) {
+  const normalizedResolved = normalizeBoolean2(resolved);
+  if (normalizedResolved === void 0) {
+    return result;
+  }
+  return {
+    ...result,
+    notes: {
+      ...result.notes,
+      nodes: result.notes.nodes.filter((n) => n.resolvable && n.resolved === normalizedResolved)
+    }
+  };
+}
+var VALID_LIST_CREATE_TYPES = ["merge_request", "issue", "epic", "snippet"];
+var VALID_GET_NOTE_TYPES = ["issue", "epic"];
+function validationError3(param, resourceType) {
+  return new Error(
+    `Missing required parameter: '${param}' is required for resource_type '${resourceType}'`
+  );
+}
+function validateListCreateParams(resourceType, args) {
+  if (!VALID_LIST_CREATE_TYPES.includes(resourceType)) {
+    throw new Error(
+      `Invalid resource_type '${resourceType}'. Must be one of: ${VALID_LIST_CREATE_TYPES.join(", ")}`
+    );
+  }
+  switch (resourceType) {
+    case "merge_request":
+    case "issue":
+      if (!args.project_id) throw validationError3("project_id", resourceType);
+      if (args.iid == null) throw validationError3("iid", resourceType);
+      break;
+    case "epic":
+      if (!args.group_id) throw validationError3("group_id", resourceType);
+      if (args.iid == null) throw validationError3("iid", resourceType);
+      break;
+    case "snippet":
+      if (!args.project_id) throw validationError3("project_id", resourceType);
+      if (args.snippet_id == null) throw validationError3("snippet_id", resourceType);
+      break;
+  }
+}
+function validateGetNoteParams(resourceType, args) {
+  if (!VALID_GET_NOTE_TYPES.includes(resourceType)) {
+    throw new Error(
+      `Invalid resource_type '${resourceType}'. Must be one of: ${VALID_GET_NOTE_TYPES.join(", ")}`
+    );
+  }
+  if (args.note_id == null) throw validationError3("note_id", resourceType);
+  switch (resourceType) {
+    case "issue":
+      if (!args.project_id) throw validationError3("project_id", resourceType);
+      if (args.iid == null) throw validationError3("iid", resourceType);
+      break;
+    case "epic":
+      if (!args.group_id) throw validationError3("group_id", resourceType);
+      if (args.iid == null) throw validationError3("iid", resourceType);
+      break;
+  }
+}
+var notesUnifiedTools = {
+  /**
+   * List notes/comments for any GitLab resource type
+   */
+  gitlab_list_notes: tool14({
+    description: `List all notes/comments on any GitLab resource using GraphQL API with pagination support.
+Returns all comments including system notes in chronological order.
+This is easier to read than discussions which have nested structure.
+
+The response includes pagination information (pageInfo) with cursors for fetching additional pages.
+Use 'after' with the 'endCursor' from pageInfo to get the next page.
+Use 'before' with the 'startCursor' from pageInfo to get the previous page.
+
+Examples:
+- MR: resource_type="merge_request", project_id="group/project", iid=123
+- Issue: resource_type="issue", project_id="group/project", iid=456  
+- Epic: resource_type="epic", group_id="my-group", iid=1
+- Snippet: resource_type="snippet", project_id="group/project", snippet_id=789`,
+    args: {
+      resource_type: z14.enum(["merge_request", "issue", "epic", "snippet"]).describe("Type of GitLab resource"),
+      project_id: z14.string().optional().describe("Project ID or path. Required for merge_request, issue, snippet"),
+      group_id: z14.string().optional().describe("Group ID or path. Required for epic"),
+      iid: z14.number().optional().describe("Internal ID of the resource (for merge_request, issue, epic)"),
+      snippet_id: z14.number().optional().describe("Snippet ID (required for snippet)"),
+      // Filtering
+      resolved: z14.boolean().optional().describe(
+        "Filter by resolved status: true for resolved, false for unresolved. Only returns resolvable notes (excludes system notes). Client-side filtering."
+      ),
+      // Pagination
+      first: z14.number().optional().describe("Number of items to return from the beginning (default: 20, max: 100)"),
+      after: z14.string().optional().describe("Cursor for forward pagination - use endCursor from previous response"),
+      last: z14.number().optional().describe("Number of items to return from the end (for backward pagination)"),
+      before: z14.string().optional().describe("Cursor for backward pagination - use startCursor from previous response")
+    },
+    execute: async (args, _ctx) => {
+      validateListCreateParams(args.resource_type, args);
+      const client = getGitLabClient();
+      const paginationOptions = {
+        first: args.first,
+        after: args.after,
+        last: args.last,
+        before: args.before
+      };
+      let result;
+      switch (args.resource_type) {
+        case "merge_request":
+          result = await client.listMrNotes(args.project_id, args.iid, paginationOptions);
+          break;
+        case "issue":
+          result = await client.listIssueNotes(args.project_id, args.iid, paginationOptions);
+          break;
+        case "epic":
+          result = await client.listEpicNotes(args.group_id, args.iid, paginationOptions);
+          break;
+        case "snippet":
+          result = await client.listSnippetNotes(
+            args.project_id,
+            args.snippet_id,
+            paginationOptions
+          );
+          break;
+        default:
+          throw new Error(`Unsupported resource type: ${args.resource_type}`);
+      }
+      const filteredResult = filterNotesByResolved(result, args.resolved);
+      return JSON.stringify(filteredResult, null, 2);
+    }
+  }),
+  /**
+   * Get a single note/comment by its ID
+   */
+  gitlab_get_note: tool14({
+    description: `Get a single note/comment from an issue or epic by its ID.
+Returns the full details of a specific note including author, body, timestamps, and metadata.
+Useful when you need to retrieve a specific comment without fetching all notes.
+
+Supports: issues, epics (MR notes use discussions API)
+
+Examples:
+- Issue note: resource_type="issue", project_id="group/project", iid=456, note_id=123
+- Epic note: resource_type="epic", group_id="my-group", iid=1, note_id=456`,
+    args: {
+      resource_type: z14.enum(["issue", "epic"]).describe("Type of GitLab resource (issue or epic only)"),
+      note_id: z14.number().describe("The ID of the note to retrieve"),
+      project_id: z14.string().optional().describe("Project ID or path. Required for issue"),
+      group_id: z14.string().optional().describe("Group ID or path. Required for epic"),
+      iid: z14.number().describe("Internal ID of the issue or epic")
+    },
+    execute: async (args, _ctx) => {
+      validateGetNoteParams(args.resource_type, args);
+      const client = getGitLabClient();
+      switch (args.resource_type) {
+        case "issue":
+          return JSON.stringify(
+            await client.getIssueNote(args.project_id, args.iid, args.note_id),
+            null,
+            2
+          );
+        case "epic":
+          return JSON.stringify(
+            await client.getEpicNote(args.group_id, args.iid, args.note_id),
+            null,
+            2
+          );
+        default:
+          throw new Error(`Unsupported resource type: ${args.resource_type}`);
+      }
+    }
+  }),
+  /**
+   * Create a simple note/comment on any GitLab resource
+   */
+  gitlab_create_note: tool14({
+    description: `Add a simple comment/note to any GitLab resource.
+Creates a standalone comment (not part of a thread).
+
+For replying to existing discussion threads, use gitlab_create_discussion 
+with discussion_id parameter instead.
+
+Examples:
+- MR comment: resource_type="merge_request", project_id="group/project", iid=123, body="LGTM!"
+- Issue comment: resource_type="issue", project_id="group/project", iid=456, body="Working on this"
+- Epic comment: resource_type="epic", group_id="my-group", iid=1, body="Planning complete"
+- Snippet comment: resource_type="snippet", project_id="group/project", snippet_id=789, body="Nice code!"`,
+    args: {
+      resource_type: z14.enum(["merge_request", "issue", "epic", "snippet"]).describe("Type of GitLab resource"),
+      body: z14.string().describe("The content of the note/comment (supports Markdown)"),
+      project_id: z14.string().optional().describe("Project ID or path. Required for merge_request, issue, snippet"),
+      group_id: z14.string().optional().describe("Group ID or path. Required for epic"),
+      iid: z14.number().optional().describe("Internal ID of the resource (for merge_request, issue, epic)"),
+      snippet_id: z14.number().optional().describe("Snippet ID (required for snippet)")
+    },
+    execute: async (args, _ctx) => {
+      validateListCreateParams(args.resource_type, args);
+      const client = getGitLabClient();
+      switch (args.resource_type) {
+        case "merge_request":
+          return JSON.stringify(
+            await client.createMrNote(args.project_id, args.iid, args.body),
+            null,
+            2
+          );
+        case "issue":
+          return JSON.stringify(
+            await client.createIssueNote(args.project_id, args.iid, args.body),
+            null,
+            2
+          );
+        case "epic":
+          return JSON.stringify(
+            await client.createEpicNote(args.group_id, args.iid, args.body),
+            null,
+            2
+          );
+        case "snippet":
+          return JSON.stringify(
+            await client.createSnippetNote(args.project_id, args.snippet_id, args.body),
+            null,
+            2
+          );
+        default:
+          throw new Error(`Unsupported resource type: ${args.resource_type}`);
+      }
+    }
+  })
+};
+
+// src/tools/git.ts
+import { tool as tool15 } from "@opencode-ai/plugin";
+
+// src/client/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { existsSync, statSync } from "fs";
+import { resolve, join } from "path";
+var execFileAsync = promisify(execFile);
+var GitClient = class _GitClient {
+  workingDirectory;
+  // Whitelist of allowed git commands (read-only operations)
+  static ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
+    "status",
+    "log",
+    "show",
+    "diff",
+    "branch",
+    "tag",
+    "remote",
+    "ls-files",
+    "ls-remote",
+    "rev-parse",
+    "describe",
+    "config",
+    "blame",
+    "shortlog",
+    "reflog",
+    "show-ref",
+    "ls-tree",
+    "cat-file",
+    "rev-list",
+    "name-rev",
+    "show-branch",
+    "whatchanged",
+    "grep",
+    "annotate"
+  ]);
+  // Commands that are explicitly forbidden (destructive operations)
+  static FORBIDDEN_COMMANDS = /* @__PURE__ */ new Set([
+    "push",
+    "pull",
+    "fetch",
+    "clone",
+    "commit",
+    "add",
+    "rm",
+    "mv",
+    "reset",
+    "rebase",
+    "merge",
+    "cherry-pick",
+    "revert",
+    "clean",
+    "checkout",
+    "switch",
+    "restore",
+    "stash",
+    "submodule",
+    "worktree"
+  ]);
+  // Shell operators that should be blocked
+  static SHELL_OPERATORS = [";", "&&", "||", "|", "`", "$("];
+  constructor(workingDirectory) {
+    this.workingDirectory = workingDirectory || process.cwd();
+  }
+  /**
+   * Execute a git command in the repository working directory
+   *
+   * Security: Uses execFile() instead of exec() to prevent command injection.
+   * Arguments are passed directly to git without shell interpretation, making
+   * attacks like `--format="$(malicious)"` impossible.
+   *
+   * @param command - The git command to execute (without 'git' prefix)
+   * @param args - Array of arguments for the command
+   * @returns Command output
+   * @throws Error if command is not allowed or execution fails
+   */
+  async runGitCommand(command, args = []) {
+    this.validateCommand(command, args);
+    try {
+      const { stdout, stderr } = await execFileAsync("git", [command, ...args], {
+        cwd: this.workingDirectory,
+        maxBuffer: 10 * 1024 * 1024,
+        // 10MB buffer
+        timeout: 3e4
+        // 30 second timeout
+      });
+      return stderr ? `${stdout}
+
+Warnings/Info:
+${stderr}` : stdout;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Git command failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Validate that a git command is safe to execute
+   * @param command - The git command
+   * @param args - Command arguments
+   * @throws Error if command is not allowed
+   */
+  validateCommand(command, args) {
+    if (_GitClient.FORBIDDEN_COMMANDS.has(command)) {
+      throw new Error(
+        `Git command '${command}' is not allowed. Only read-only operations are permitted.`
+      );
+    }
+    if (!_GitClient.ALLOWED_COMMANDS.has(command)) {
+      throw new Error(
+        `Git command '${command}' is not in the allowed list. Only safe, read-only operations are permitted.`
+      );
+    }
+    if (command === "branch" && args.some((arg) => arg === "-d" || arg === "-D" || arg === "-m")) {
+      throw new Error("Branch deletion and renaming operations are not allowed.");
+    }
+    if (command === "tag" && args.some((arg) => arg === "-d" || arg === "-f")) {
+      throw new Error("Tag deletion and force operations are not allowed.");
+    }
+    if (command === "remote" && args.some((arg) => arg === "add" || arg === "remove" || arg === "set-url")) {
+      throw new Error("Remote modification operations are not allowed.");
+    }
+    if (command === "config" && args.length > 0 && !args.some((arg) => arg.startsWith("--get"))) {
+      throw new Error("Only git config read operations (--get) are allowed.");
+    }
+    const allArgs = [command, ...args].join(" ");
+    if (_GitClient.SHELL_OPERATORS.some((op) => allArgs.includes(op))) {
+      throw new Error("Command contains potentially dangerous shell operators.");
+    }
+  }
+  /**
+   * Validate that a directory exists and is a git repository
+   * @param directory - Path to validate
+   * @throws Error if directory is invalid or not a git repository
+   */
+  validateDirectory(directory) {
+    const absolutePath = resolve(directory);
+    if (!existsSync(absolutePath)) {
+      throw new Error(`Directory does not exist: ${absolutePath}`);
+    }
+    const stats = statSync(absolutePath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${absolutePath}`);
+    }
+    const gitDir = join(absolutePath, ".git");
+    if (!existsSync(gitDir)) {
+      throw new Error(`Not a git repository: ${absolutePath}`);
+    }
+  }
+  /**
+   * Get the current working directory
+   */
+  getWorkingDirectory() {
+    return this.workingDirectory;
+  }
+  /**
+   * Set the working directory for git commands
+   * @param directory - Path to the git repository
+   * @throws Error if directory is invalid or not a git repository
+   */
+  setWorkingDirectory(directory) {
+    this.validateDirectory(directory);
+    this.workingDirectory = resolve(directory);
+  }
+};
+
+// src/tools/git.ts
+var z15 = tool15.schema;
+var gitClient = null;
+function getGitClient() {
+  if (!gitClient) {
+    gitClient = new GitClient();
+  }
+  return gitClient;
+}
+var gitTools = {
+  run_git_command: tool15({
+    description: `Execute safe, read-only git commands in the repository working directory.
+
+Security restrictions:
+- Only read-only git commands are allowed (status, log, show, diff, branch, tag, etc.)
+- Destructive operations are forbidden (push, pull, commit, add, rm, reset, merge, etc.)
+- Shell operators and command injection attempts are blocked
+- Commands are executed with a 30-second timeout and 10MB output buffer
+
+Allowed commands include:
+- status: Show working tree status
+- log: Show commit logs
+- show: Show various types of objects
+- diff: Show changes between commits, commit and working tree, etc.
+- branch: List, create, or delete branches (read-only: list only)
+- tag: List tags (read-only: list only)
+- remote: List remote repositories (read-only: list only)
+- ls-files: Show information about files in the index and working tree
+- ls-remote: List references in a remote repository
+- rev-parse: Parse revision (or other objects) names
+- describe: Give an object a human readable name based on an available ref
+- config: Get repository configuration (read-only: --get operations only)
+- blame: Show what revision and author last modified each line of a file
+- shortlog: Summarize git log output
+- reflog: Show reference logs
+- show-ref: List references in a local repository
+- ls-tree: List the contents of a tree object
+- cat-file: Provide content or type and size information for repository objects
+- rev-list: List commit objects in reverse chronological order
+- name-rev: Find symbolic names for given revs
+- show-branch: Show branches and their commits
+- whatchanged: Show logs with difference each commit introduces
+- grep: Print lines matching a pattern
+- annotate: Annotate file lines with commit information
+
+Examples:
+- run_git_command("status", []) - Show working tree status
+- run_git_command("log", ["--oneline", "-10"]) - Show last 10 commits
+- run_git_command("diff", ["HEAD~1", "HEAD"]) - Show diff between last two commits
+- run_git_command("branch", ["-a"]) - List all branches
+- run_git_command("show", ["HEAD:README.md"]) - Show README.md from HEAD commit`,
+    args: {
+      command: z15.string().describe('The git command to execute (without "git" prefix)'),
+      args: z15.array(z15.string()).optional().describe("Array of arguments for the git command (default: [])"),
+      working_directory: z15.string().optional().describe(
+        "Path to the git repository (default: current working directory). Use this to execute git commands in a specific repository."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitClient();
+      if (args.working_directory) {
+        client.setWorkingDirectory(args.working_directory);
+      }
+      try {
+        const output = await client.runGitCommand(args.command, args.args || []);
+        return output;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(`Failed to execute git command: ${error.message}`);
+        }
+        throw error;
+      }
+    }
+  })
+};
+
+// src/tools/audit.ts
+import { tool as tool16 } from "@opencode-ai/plugin";
+var z16 = tool16.schema;
+var auditTools = {
+  gitlab_list_project_audit_events: tool16({
+    description: `List audit events for a project.
+Returns audit events including actions like project settings changes, member additions/removals, and other security-relevant activities.
+Note: Requires project owner role or higher.`,
+    args: {
+      project_id: z16.string().describe("The project ID or URL-encoded path"),
+      created_after: z16.string().optional().describe("Return audit events created after this date (ISO 8601 format)"),
+      created_before: z16.string().optional().describe("Return audit events created before this date (ISO 8601 format)"),
+      entity_type: z16.string().optional().describe('Filter by entity type (e.g., "User", "Project", "Group")'),
+      entity_id: z16.number().optional().describe("Filter by entity ID"),
+      author_id: z16.number().optional().describe("Filter by author user ID"),
+      per_page: z16.number().optional().describe("Number of results per page (default: 20)"),
+      page: z16.number().optional().describe("Page number for pagination (default: 1)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const events = await client.listProjectAuditEvents(args.project_id, {
+        created_after: args.created_after,
+        created_before: args.created_before,
+        entity_type: args.entity_type,
+        entity_id: args.entity_id,
+        author_id: args.author_id,
+        per_page: args.per_page,
+        page: args.page
+      });
+      return JSON.stringify(events, null, 2);
+    }
+  }),
+  gitlab_list_group_audit_events: tool16({
+    description: `List audit events for a group.
+Returns audit events including actions like group settings changes, member additions/removals, subgroup operations, and other security-relevant activities.
+Note: Requires group owner role or higher.`,
+    args: {
+      group_id: z16.string().describe("The group ID or URL-encoded path"),
+      created_after: z16.string().optional().describe("Return audit events created after this date (ISO 8601 format)"),
+      created_before: z16.string().optional().describe("Return audit events created before this date (ISO 8601 format)"),
+      entity_type: z16.string().optional().describe('Filter by entity type (e.g., "User", "Project", "Group")'),
+      entity_id: z16.number().optional().describe("Filter by entity ID"),
+      author_id: z16.number().optional().describe("Filter by author user ID"),
+      per_page: z16.number().optional().describe("Number of results per page (default: 20)"),
+      page: z16.number().optional().describe("Page number for pagination (default: 1)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const events = await client.listGroupAuditEvents(args.group_id, {
+        created_after: args.created_after,
+        created_before: args.created_before,
+        entity_type: args.entity_type,
+        entity_id: args.entity_id,
+        author_id: args.author_id,
+        per_page: args.per_page,
+        page: args.page
+      });
+      return JSON.stringify(events, null, 2);
+    }
+  }),
+  gitlab_list_instance_audit_events: tool16({
+    description: `List instance-level audit events.
+Returns audit events for the entire GitLab instance including actions like instance settings changes, user management, license changes, and other system-wide security-relevant activities.
+Note: Requires administrator access.`,
+    args: {
+      created_after: z16.string().optional().describe("Return audit events created after this date (ISO 8601 format)"),
+      created_before: z16.string().optional().describe("Return audit events created before this date (ISO 8601 format)"),
+      entity_type: z16.string().optional().describe('Filter by entity type (e.g., "User", "Project", "Group")'),
+      entity_id: z16.number().optional().describe("Filter by entity ID"),
+      author_id: z16.number().optional().describe("Filter by author user ID"),
+      per_page: z16.number().optional().describe("Number of results per page (default: 20)"),
+      page: z16.number().optional().describe("Page number for pagination (default: 1)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const events = await client.listInstanceAuditEvents({
+        created_after: args.created_after,
+        created_before: args.created_before,
+        entity_type: args.entity_type,
+        entity_id: args.entity_id,
+        author_id: args.author_id,
+        per_page: args.per_page,
+        page: args.page
+      });
+      return JSON.stringify(events, null, 2);
+    }
+  })
+};
+
+// src/tools/award-emoji.ts
+import { tool as tool17 } from "@opencode-ai/plugin";
+var z17 = tool17.schema;
+function validateAwardEmojiParams(args) {
+  if (!args.project_id) {
+    throw new Error("project_id is required");
+  }
+  if (args.resource_iid == null) {
+    throw new Error("resource_iid is required");
+  }
+}
+function buildResourceId(args) {
+  return {
+    projectId: args.project_id,
+    resourceType: args.resource_type,
+    resourceIid: args.resource_iid,
+    noteId: args.note_id
+  };
+}
+var awardEmojiTools = {
+  /**
+   * Add a reaction (award emoji) to a resource or note
+   */
+  gitlab_create_award_emoji: tool17({
+    description: `Add a reaction (award emoji) to a merge request, issue, snippet, or a note/comment on these resources.
+
+Common emoji names: thumbsup, thumbsdown, smile, tada, rocket, eyes, heart, +1, -1
+
+To react to a specific comment/note, provide the note_id parameter.
+
+Examples:
+- React to MR: resource_type="merge_request", project_id="group/project", resource_iid=123, name="thumbsup"
+- React to issue comment: resource_type="issue", project_id="group/project", resource_iid=456, note_id=789, name="rocket"`,
+    args: {
+      resource_type: z17.enum(["merge_request", "issue", "snippet"]).describe("Type of resource to add the reaction to"),
+      project_id: z17.string().describe("Project ID or URL-encoded path"),
+      resource_iid: z17.number().describe("Internal ID of the merge request, issue, or snippet"),
+      name: z17.string().describe(
+        'Emoji name without colons (e.g., "thumbsup", "rocket", "eyes", "heart", "tada")'
+      ),
+      note_id: z17.number().optional().describe("Note/comment ID to add the reaction to (if reacting to a specific comment)")
+    },
+    execute: async (args, _ctx) => {
+      validateAwardEmojiParams(args);
+      const client = getGitLabClient();
+      const resource = buildResourceId(args);
+      const result = await client.createAwardEmoji(resource, args.name);
+      return JSON.stringify(result, null, 2);
+    }
+  }),
+  /**
+   * List all reactions on a resource or note
+   */
+  gitlab_list_award_emoji: tool17({
+    description: `List all reactions (award emoji) on a merge request, issue, snippet, or a specific note/comment.
+
+Examples:
+- List reactions on MR: resource_type="merge_request", project_id="group/project", resource_iid=123
+- List reactions on a comment: resource_type="issue", project_id="group/project", resource_iid=456, note_id=789`,
+    args: {
+      resource_type: z17.enum(["merge_request", "issue", "snippet"]).describe("Type of resource"),
+      project_id: z17.string().describe("Project ID or URL-encoded path"),
+      resource_iid: z17.number().describe("Internal ID of the merge request, issue, or snippet"),
+      note_id: z17.number().optional().describe("Note/comment ID to list reactions for (if listing for a specific comment)")
+    },
+    execute: async (args, _ctx) => {
+      validateAwardEmojiParams(args);
+      const client = getGitLabClient();
+      const resource = buildResourceId(args);
+      const result = await client.listAwardEmoji(resource);
+      return JSON.stringify(result, null, 2);
+    }
+  }),
+  /**
+   * Remove a reaction from a resource or note
+   */
+  gitlab_delete_award_emoji: tool17({
+    description: `Remove a reaction (award emoji) from a merge request, issue, snippet, or note/comment.
+
+You need the award_id which can be found using gitlab_list_award_emoji.
+
+Examples:
+- Remove reaction from MR: resource_type="merge_request", project_id="group/project", resource_iid=123, award_id=456
+- Remove from comment: resource_type="issue", ..., note_id=789, award_id=456`,
+    args: {
+      resource_type: z17.enum(["merge_request", "issue", "snippet"]).describe("Type of resource"),
+      project_id: z17.string().describe("Project ID or URL-encoded path"),
+      resource_iid: z17.number().describe("Internal ID of the merge request, issue, or snippet"),
+      award_id: z17.number().describe("ID of the award emoji to remove"),
+      note_id: z17.number().optional().describe("Note/comment ID if removing from a specific comment")
+    },
+    execute: async (args, _ctx) => {
+      validateAwardEmojiParams(args);
+      const client = getGitLabClient();
+      const resource = buildResourceId(args);
+      await client.deleteAwardEmoji(resource, args.award_id);
+      return JSON.stringify({ success: true, message: "Award emoji removed" }, null, 2);
+    }
+  })
+};
+
+// src/index.ts
+var gitlabPlugin = async (_input) => {
+  return {
+    tool: {
+      // Merge Request Tools
+      ...mergeRequestTools,
+      // Issue Tools
+      ...issueTools,
+      // Epic Tools
+      ...epicTools,
+      // Pipeline Tools
+      ...pipelineTools,
+      // Repository Tools
+      ...repositoryTools,
+      // Search Tools
+      ...searchTools,
+      // Project Tools
+      ...projectTools,
+      // User Tools
+      ...userTools,
+      // Security Tools
+      ...securityTools,
+      // TODO Tools
+      ...todoTools,
+      // Wiki Tools
+      ...wikiTools,
+      // Work Item Tools
+      ...workItemTools,
+      // Unified Discussion Tools (covers MR, issue, epic, commit, snippet discussions)
+      ...discussionsUnifiedTools,
+      // Unified Notes Tools (covers MR, issue, epic, snippet notes)
+      ...notesUnifiedTools,
+      // Git Tools
+      ...gitTools,
+      // Audit Tools
+      ...auditTools,
+      // Award Emoji (Reactions) Tools
+      ...awardEmojiTools
+    }
+  };
+};
+var index_default = gitlabPlugin;
+export {
+  index_default as default,
+  gitlabPlugin
+};