@gitlab/opencode-gitlab-plugin 1.0.1

package/dist/index.js

@@ -0,0 +1,3853 @@
+// 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/merge-requests.ts
+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`
+    );
+  }
+  async listMrDiscussions(projectId, mrIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/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 }
+    );
+  }
+  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 listMrNotes(projectId, mrIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/merge_requests/${mrIid}/notes`
+    );
+  }
+  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`
+    );
+  }
+  /**
+   * List merge request diffs with pagination support
+   * API: GET /projects/:id/merge_requests/:merge_request_iid/diffs
+   */
+  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);
+  }
+};
+
+// src/client/issues.ts
+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);
+  }
+  async listIssueNotes(projectId, issueIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/issues/${issueIid}/notes`
+    );
+  }
+  async listIssueDiscussions(projectId, issueIid) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/issues/${issueIid}/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 }
+    );
+  }
+  /**
+   * Get a single note from an issue
+   * API: GET /projects/:id/issues/:issue_iid/notes/:note_id
+   */
+  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");
+  }
+};
+
+// 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 TodosClient = class extends GitLabApiClient {
+  async listTodos(options) {
+    const params = new URLSearchParams();
+    params.set("per_page", String(options?.limit || 20));
+    if (options?.action) params.set("action", options.action);
+    if (options?.author_id) params.set("author_id", String(options.author_id));
+    if (options?.project_id) {
+      const encodedProject = this.encodeProjectId(options.project_id);
+      params.set("project_id", encodedProject);
+    }
+    if (options?.group_id) params.set("group_id", options.group_id);
+    if (options?.state) params.set("state", options.state);
+    if (options?.type) params.set("type", options.type);
+    return this.fetch("GET", `/todos?${params}`);
+  }
+  async markTodoAsDone(todoId) {
+    return this.fetch("POST", `/todos/${todoId}/mark_as_done`);
+  }
+  async markAllTodosAsDone() {
+    return this.fetch("POST", "/todos/mark_as_done");
+  }
+  async getTodoCount() {
+    return this.fetch("GET", "/todos/count");
+  }
+};
+
+// src/client/epics.ts
+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}`
+    );
+  }
+  async listEpicNotes(groupId, epicIid) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "GET",
+      `/groups/${encodedGroup}/epics/${epicIid}/notes`
+    );
+  }
+  async listEpicDiscussions(groupId, epicIid) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "GET",
+      `/groups/${encodedGroup}/epics/${epicIid}/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 }
+    );
+  }
+  /**
+   * Get a single note from an epic
+   * API: GET /groups/:id/epics/:epic_iid/notes/:note_id
+   */
+  async getEpicNote(groupId, epicIid, noteId) {
+    const encodedGroup = encodeURIComponent(groupId);
+    return this.fetch(
+      "GET",
+      `/groups/${encodedGroup}/epics/${epicIid}/notes/${noteId}`
+    );
+  }
+};
+
+// src/client/snippets.ts
+var SnippetsClient = class extends GitLabApiClient {
+  async listSnippetDiscussions(projectId, snippetId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/snippets/${snippetId}/discussions`
+    );
+  }
+  async getSnippetDiscussion(projectId, snippetId, discussionId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/snippets/${snippetId}/discussions/${discussionId}`
+    );
+  }
+  async listSnippetNotes(projectId, snippetId) {
+    const encodedProject = this.encodeProjectId(projectId);
+    return this.fetch(
+      "GET",
+      `/projects/${encodedProject}/snippets/${snippetId}/notes`
+    );
+  }
+  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/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
+]);
+
+// 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_list_mr_discussions: tool({
+    description: `List discussions (comment threads) on a merge request.
+Returns all discussion threads with nested notes. Each discussion contains a 'notes' array with individual comments.
+Note: For a flattened list of all comments, use gitlab_list_mr_notes instead.`,
+    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 discussions = await client.listMrDiscussions(args.project_id, args.mr_iid);
+      return JSON.stringify(discussions, null, 2);
+    }
+  }),
+  gitlab_list_mr_notes: tool({
+    description: `List all notes/comments on a merge request in a flat structure.
+Returns all comments including system notes, code review comments, and general discussion.
+This is easier to read than discussions which have nested structure.`,
+    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 notes = await client.listMrNotes(args.project_id, args.mr_iid);
+      return JSON.stringify(notes, null, 2);
+    }
+  }),
+  gitlab_create_mr_note: tool({
+    description: `Add a comment/note to a merge request.
+If discussion_id is provided, the note will be added as a reply to an existing discussion thread.
+Use gitlab_list_mr_discussions to find discussion IDs for existing threads.`,
+    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"),
+      body: z.string().describe("The content of the note/comment (supports Markdown)"),
+      discussion_id: z.string().optional().describe(
+        "The ID of a discussion thread to reply to. If provided, the note will be added as a reply to that discussion."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const note = await client.createMrNote(
+        args.project_id,
+        args.mr_iid,
+        args.body,
+        args.discussion_id
+      );
+      return JSON.stringify(note, null, 2);
+    }
+  }),
+  gitlab_get_mr_discussion: tool({
+    description: `Get a specific discussion thread from a merge request with all its replies.
+Returns the discussion with its 'notes' array containing all comments in the thread.
+Use this to get the full context of a specific conversation.`,
+    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"),
+      discussion_id: z.string().describe("The ID of the discussion thread")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.getMrDiscussion(
+        args.project_id,
+        args.mr_iid,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_resolve_mr_discussion: tool({
+    description: `Mark a merge request discussion thread as resolved.
+Use this after addressing feedback in a code review to indicate the discussion is complete.
+Only works for resolvable discussions (typically code review comments).`,
+    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"),
+      discussion_id: z.string().describe("The ID of the discussion thread to resolve")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.resolveMrDiscussion(
+        args.project_id,
+        args.mr_iid,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_unresolve_mr_discussion: tool({
+    description: `Reopen a resolved merge request discussion thread.
+Use this to indicate that a previously resolved discussion needs more attention.`,
+    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"),
+      discussion_id: z.string().describe("The ID of the discussion thread to unresolve")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.unresolveMrDiscussion(
+        args.project_id,
+        args.mr_iid,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_create_mr_discussion: tool({
+    description: `Start a new discussion thread on a merge request.
+Creates a new discussion with an initial comment. Optionally can be positioned on specific code.
+For general comments, just provide the body. For code comments, provide position information.`,
+    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"),
+      body: z.string().describe("The content of the initial comment (supports Markdown)"),
+      position: z.object({
+        base_sha: z.string().describe("SHA of the base commit (merge base)"),
+        start_sha: z.string().describe("SHA of the commit when the MR was created"),
+        head_sha: z.string().describe("SHA of the HEAD commit"),
+        position_type: z.enum(["text", "image"]).describe("Type of position (text or image)"),
+        new_path: z.string().optional().describe("Path of the file after changes"),
+        old_path: z.string().optional().describe("Path of the file before changes"),
+        new_line: z.number().optional().describe("Line number in the new version"),
+        old_line: z.number().optional().describe("Line number in the old version")
+      }).optional().describe(
+        "Position information for code comments. Required fields: base_sha, start_sha, head_sha, position_type. For line comments also provide new_path/old_path and new_line/old_line."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.createMrDiscussion(
+        args.project_id,
+        args.mr_iid,
+        args.body,
+        args.position
+      );
+      return JSON.stringify(discussion, 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_commits: tool({
+    description: `Get the list of commits in a merge request.
+Returns all commits that are part of the merge request.`,
+    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 commits = await client.getMrCommits(args.project_id, args.mr_iid);
+      return JSON.stringify(commits, null, 2);
+    }
+  }),
+  gitlab_get_mr_pipelines: tool({
+    description: `Get the list of pipelines for a merge request.
+Returns all pipelines that ran for the merge request.`,
+    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 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);
+    }
+  })
+};
+
+// 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);
+    }
+  }),
+  gitlab_list_issue_notes: tool2({
+    description: `List all notes/comments on an issue.
+Returns all comments including system notes in chronological order.`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      issue_iid: z2.number().describe("The internal ID of the issue")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const notes = await client.listIssueNotes(args.project_id, args.issue_iid);
+      return JSON.stringify(notes, null, 2);
+    }
+  }),
+  gitlab_list_issue_discussions: tool2({
+    description: `List discussions (comment threads) on an issue.
+Returns all discussion threads with nested notes. Each discussion contains a 'notes' array with individual comments.
+Use the discussion 'id' field to reply to a specific thread with gitlab_create_issue_note.`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      issue_iid: z2.number().describe("The internal ID of the issue")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussions = await client.listIssueDiscussions(args.project_id, args.issue_iid);
+      return JSON.stringify(discussions, null, 2);
+    }
+  }),
+  gitlab_create_issue_note: tool2({
+    description: `Add a comment/note to an issue.
+If discussion_id is provided, the note will be added as a reply to an existing discussion thread.
+Use gitlab_list_issue_discussions to find discussion IDs for existing threads.`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      issue_iid: z2.number().describe("The internal ID of the issue"),
+      body: z2.string().describe("The content of the note/comment (supports Markdown)"),
+      discussion_id: z2.string().optional().describe(
+        "The ID of a discussion thread to reply to. If provided, the note will be added as a reply to that discussion."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const note = await client.createIssueNote(
+        args.project_id,
+        args.issue_iid,
+        args.body,
+        args.discussion_id
+      );
+      return JSON.stringify(note, null, 2);
+    }
+  }),
+  gitlab_get_issue_discussion: tool2({
+    description: `Get a specific discussion thread from an issue with all its replies.
+Returns the discussion with its 'notes' array containing all comments in the thread.
+Use this to get the full context of a specific conversation.`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      issue_iid: z2.number().describe("The internal ID of the issue"),
+      discussion_id: z2.string().describe("The ID of the discussion thread")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.getIssueDiscussion(
+        args.project_id,
+        args.issue_iid,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_resolve_issue_discussion: tool2({
+    description: `Mark an issue discussion thread as resolved.
+Use this after addressing feedback in a code review or issue discussion to indicate the discussion is complete.
+Only works for resolvable discussions (typically multi-note threads, not individual notes).`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      issue_iid: z2.number().describe("The internal ID of the issue"),
+      discussion_id: z2.string().describe("The ID of the discussion thread to resolve")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.resolveIssueDiscussion(
+        args.project_id,
+        args.issue_iid,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_unresolve_issue_discussion: tool2({
+    description: `Reopen a resolved issue discussion thread.
+Use this to indicate that a previously resolved discussion needs more attention or further discussion.`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      issue_iid: z2.number().describe("The internal ID of the issue"),
+      discussion_id: z2.string().describe("The ID of the discussion thread to unresolve")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.unresolveIssueDiscussion(
+        args.project_id,
+        args.issue_iid,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_get_issue_note: tool2({
+    description: `Get a single note/comment from an issue 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.`,
+    args: {
+      project_id: z2.string().describe("The project ID or URL-encoded path"),
+      issue_iid: z2.number().describe("The internal ID of the issue"),
+      note_id: z2.number().describe("The ID of the note to retrieve")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const note = await client.getIssueNote(args.project_id, args.issue_iid, args.note_id);
+      return JSON.stringify(note, null, 2);
+    }
+  })
+};
+
+// src/tools/epics.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+var z3 = tool3.schema;
+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_list_epic_issues: tool3({
+    description: `Get all issues associated with an epic.
+Returns the list of issues that are linked to the epic.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const issues = await client.listEpicIssues(args.group_id, args.epic_iid);
+      return JSON.stringify(issues, null, 2);
+    }
+  }),
+  gitlab_add_issue_to_epic: tool3({
+    description: `Link an existing issue to an epic.
+The issue can be from any project within the group hierarchy.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic"),
+      issue_id: z3.number().describe("The global ID of the issue to add")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const result = await client.addIssueToEpic(args.group_id, args.epic_iid, args.issue_id);
+      return JSON.stringify(result, null, 2);
+    }
+  }),
+  gitlab_remove_issue_from_epic: tool3({
+    description: `Unlink an issue from an epic.
+Removes the association between the issue and the epic.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic"),
+      epic_issue_id: z3.number().describe("The ID of the epic-issue association (from list_epic_issues)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const result = await client.removeIssueFromEpic(
+        args.group_id,
+        args.epic_iid,
+        args.epic_issue_id
+      );
+      return JSON.stringify(result, null, 2);
+    }
+  }),
+  gitlab_list_epic_notes: tool3({
+    description: `List all comments/notes on an epic in a flat structure.
+Returns all comments in chronological order.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const notes = await client.listEpicNotes(args.group_id, args.epic_iid);
+      return JSON.stringify(notes, null, 2);
+    }
+  }),
+  gitlab_list_epic_discussions: tool3({
+    description: `List discussions (comment threads) on an epic.
+Returns all discussion threads with nested notes. Each discussion contains a 'notes' array with individual comments.
+Use the discussion 'id' field to reply to a specific thread with gitlab_create_epic_note.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussions = await client.listEpicDiscussions(args.group_id, args.epic_iid);
+      return JSON.stringify(discussions, null, 2);
+    }
+  }),
+  gitlab_create_epic_note: tool3({
+    description: `Add a comment/note to an epic.
+If discussion_id is provided, the note will be added as a reply to an existing discussion thread.
+Use gitlab_list_epic_discussions to find discussion IDs for existing threads.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic"),
+      body: z3.string().describe("The content of the note/comment (supports Markdown)"),
+      discussion_id: z3.string().optional().describe(
+        "The ID of a discussion thread to reply to. If provided, the note will be added as a reply to that discussion."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const note = await client.createEpicNote(
+        args.group_id,
+        args.epic_iid,
+        args.body,
+        args.discussion_id
+      );
+      return JSON.stringify(note, null, 2);
+    }
+  }),
+  gitlab_get_epic_discussion: tool3({
+    description: `Get a specific discussion thread from an epic with all its replies.
+Returns the discussion with its 'notes' array containing all comments in the thread.
+Use this to get the full context of a specific conversation.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic"),
+      discussion_id: z3.string().describe("The ID of the discussion thread")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.getEpicDiscussion(
+        args.group_id,
+        args.epic_iid,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_get_epic_note: tool3({
+    description: `Get a single note/comment from an 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.`,
+    args: {
+      group_id: z3.string().describe("The group ID or URL-encoded path"),
+      epic_iid: z3.number().describe("The internal ID of the epic"),
+      note_id: z3.number().describe("The ID of the note to retrieve")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const note = await client.getEpicNote(args.group_id, args.epic_iid, args.note_id);
+      return JSON.stringify(note, 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
+
+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)
+- jobs: list of jobs that would be created (optional, requires include_jobs=true)`,
+    args: {
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      content: z4.string().describe("The CI/CD configuration content (YAML as string)"),
+      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)"
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      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);
+    }
+  }),
+  gitlab_lint_existing_ci_config: tool4({
+    description: `Validate an existing .gitlab-ci.yml configuration from the repository.
+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
+
+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 with their locations (optional)
+- jobs: list of jobs that would be created (optional, requires include_jobs=true)`,
+    args: {
+      project_id: z4.string().describe("The project ID or URL-encoded path"),
+      content_ref: z4.string().optional().describe(
+        "Commit SHA, branch or tag to get CI config from (defaults to project default branch)"
+      ),
+      dry_run: z4.boolean().optional().describe("Run pipeline creation simulation instead of just static check (default: false)"),
+      dry_run_ref: z4.string().optional().describe(
+        "Branch or tag context to use for validation when dry_run is true (defaults to project default branch)"
+      ),
+      include_jobs: z4.boolean().optional().describe("Include list of jobs that would be created in the response (default: false)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const result = await client.lintExistingCiConfig(args.project_id, {
+        content_ref: args.content_ref,
+        dry_run: args.dry_run,
+        dry_run_ref: args.dry_run_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_create_commit: tool5({
+    description: `Create a commit with multiple file actions.
+Supports creating, updating, deleting, moving files, and changing permissions.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      branch: z5.string().describe("Name of the branch to commit into"),
+      commit_message: z5.string().describe("Commit message"),
+      actions: z5.array(
+        z5.object({
+          action: z5.enum(["create", "delete", "move", "update", "chmod"]).describe("The action to perform"),
+          file_path: z5.string().describe("Full path to the file"),
+          content: z5.string().optional().describe("File content (required for create/update)"),
+          encoding: z5.enum(["text", "base64"]).optional().describe("Encoding of content (default: text)"),
+          previous_path: z5.string().optional().describe("Original path (required for move)"),
+          execute_filemode: z5.boolean().optional().describe("Enable/disable execute flag (for chmod)")
+        })
+      ).describe("Array of file actions to perform"),
+      author_email: z5.string().optional().describe("Author email address"),
+      author_name: z5.string().optional().describe("Author name"),
+      start_branch: z5.string().optional().describe("Name of the branch to start from (if different from target branch)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const commit = await client.createCommit(args.project_id, {
+        branch: args.branch,
+        commit_message: args.commit_message,
+        actions: args.actions,
+        author_email: args.author_email,
+        author_name: args.author_name,
+        start_branch: args.start_branch
+      });
+      return JSON.stringify(commit, 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);
+    }
+  }),
+  // ========== Commit Discussion Tools ==========
+  gitlab_list_commit_discussions: tool5({
+    description: `List discussions (comment threads) on a commit.
+Returns all discussion threads with nested notes. Each discussion contains a 'notes' array with individual comments.
+Use the discussion 'id' field to reply to a specific thread with gitlab_create_commit_note.`,
+    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 discussions = await client.listCommitDiscussions(args.project_id, args.sha);
+      return JSON.stringify(discussions, null, 2);
+    }
+  }),
+  gitlab_get_commit_discussion: tool5({
+    description: `Get a specific discussion thread from a commit with all its replies.
+Returns the discussion with its 'notes' array containing all comments in the thread.
+Use this to get the full context of a specific conversation.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      sha: z5.string().describe("The commit SHA"),
+      discussion_id: z5.string().describe("The ID of the discussion thread")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.getCommitDiscussion(
+        args.project_id,
+        args.sha,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_create_commit_note: tool5({
+    description: `Add a comment/note to a commit.
+If discussion_id is provided, the note will be added as a reply to an existing discussion thread.
+Optionally, you can create a line-specific comment by providing path, line, and line_type.
+Use gitlab_list_commit_discussions to find discussion IDs for existing threads.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      sha: z5.string().describe("The commit SHA"),
+      body: z5.string().describe("The content of the note/comment (supports Markdown)"),
+      discussion_id: z5.string().optional().describe(
+        "The ID of a discussion thread to reply to. If provided, the note will be added as a reply to that discussion."
+      ),
+      path: z5.string().optional().describe("The file path to comment on (for line-specific comments)"),
+      line: z5.number().optional().describe("The line number to comment on (for line-specific comments)"),
+      line_type: z5.enum(["new", "old"]).optional().describe(
+        'The type of line being commented on: "new" for added lines, "old" for removed lines'
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const note = await client.createCommitNote(args.project_id, args.sha, args.body, {
+        discussion_id: args.discussion_id,
+        path: args.path,
+        line: args.line,
+        line_type: args.line_type
+      });
+      return JSON.stringify(note, null, 2);
+    }
+  }),
+  gitlab_create_commit_discussion: tool5({
+    description: `Start a new discussion thread on a commit.
+Creates a new discussion with an initial comment. Optionally can be positioned on specific code.
+For general comments, just provide the body. For code comments, provide position information.`,
+    args: {
+      project_id: z5.string().describe("The project ID or URL-encoded path"),
+      sha: z5.string().describe("The commit SHA"),
+      body: z5.string().describe("The content of the initial comment (supports Markdown)"),
+      position: z5.object({
+        base_sha: z5.string().describe("SHA of the base commit"),
+        start_sha: z5.string().describe("SHA of the start commit"),
+        head_sha: z5.string().describe("SHA of the HEAD commit"),
+        position_type: z5.enum(["text", "image"]).describe("Type of position (text or image)"),
+        new_path: z5.string().optional().describe("Path of the file after changes"),
+        old_path: z5.string().optional().describe("Path of the file before changes"),
+        new_line: z5.number().optional().describe("Line number in the new version"),
+        old_line: z5.number().optional().describe("Line number in the old version")
+      }).optional().describe(
+        "Position information for code comments. Required fields: base_sha, start_sha, head_sha, position_type. For line comments also provide new_path/old_path and new_line/old_line."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.createCommitDiscussion(
+        args.project_id,
+        args.sha,
+        args.body,
+        args.position
+      );
+      return JSON.stringify(discussion, 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);
+    }
+  })
+};
+var commitDiscussionTools = {
+  gitlab_list_commit_discussions: repositoryTools.gitlab_list_commit_discussions,
+  gitlab_get_commit_discussion: repositoryTools.gitlab_get_commit_discussion,
+  gitlab_create_commit_note: repositoryTools.gitlab_create_commit_note,
+  gitlab_create_commit_discussion: repositoryTools.gitlab_create_commit_discussion
+};
+
+// src/tools/search.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
+var z6 = tool6.schema;
+var searchTools = {
+  gitlab_search: tool6({
+    description: `Search across GitLab for various resources.
+Scopes: projects, issues, merge_requests, milestones, users, blobs (code), commits, notes, wiki_blobs`,
+    args: {
+      scope: z6.enum([
+        "projects",
+        "issues",
+        "merge_requests",
+        "milestones",
+        "users",
+        "blobs",
+        "commits",
+        "notes",
+        "wiki_blobs"
+      ]).describe("The scope of the search"),
+      search: z6.string().describe("The search query"),
+      project_id: z6.string().optional().describe("Limit search to a specific project (optional)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.search(args.scope, args.search, args.project_id, args.limit);
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_issue_search: tool6({
+    description: `Search issues by keyword across GitLab.
+Specialized search for issues with better filtering than the generic search.`,
+    args: {
+      search: z6.string().describe("The search query"),
+      project_id: z6.string().optional().describe("Limit search to a specific project (optional)"),
+      state: z6.enum(["opened", "closed", "all"]).optional().describe("Filter by issue state"),
+      labels: z6.string().optional().describe("Comma-separated list of labels to filter by"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.search("issues", args.search, args.project_id, args.limit);
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_blob_search: tool6({
+    description: `Search file content in repositories.
+Search for code/text within files across projects.`,
+    args: {
+      search: z6.string().describe("The search query (code/text to find)"),
+      project_id: z6.string().optional().describe("Limit search to a specific project (optional)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.search("blobs", args.search, args.project_id, args.limit);
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_merge_request_search: tool6({
+    description: `Search merge requests by keyword.
+Specialized search for merge requests with better filtering than the generic search.`,
+    args: {
+      search: z6.string().describe("The search query"),
+      project_id: z6.string().optional().describe("Limit search to a specific project (optional)"),
+      state: z6.enum(["opened", "closed", "merged", "all"]).optional().describe("Filter by MR state"),
+      labels: z6.string().optional().describe("Comma-separated list of labels to filter by"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.search(
+        "merge_requests",
+        args.search,
+        args.project_id,
+        args.limit
+      );
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_commit_search: tool6({
+    description: `Search for commits in a project or across GitLab.
+Returns commits matching the search query with commit details including SHA, title, message, author, and dates.
+
+Supports searching by:
+- Commit message content
+- Author name or email
+- Commit SHA (partial or full)
+
+Note: Advanced search features (Premium/Ultimate) provide better commit search capabilities.`,
+    args: {
+      search: z6.string().describe("The search query (commit message, author, or SHA)"),
+      project_id: z6.string().optional().describe("Limit search to a specific project (optional)"),
+      ref: z6.string().optional().describe("Branch or tag name to search on (defaults to default branch)"),
+      order_by: z6.enum(["created_at"]).optional().describe("Order results by created_at (default: created_at desc)"),
+      sort: z6.enum(["asc", "desc"]).optional().describe("Sort order (asc or desc)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.searchCommits(args.search, args.project_id, {
+        ref: args.ref,
+        order_by: args.order_by,
+        sort: args.sort,
+        limit: args.limit
+      });
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_group_project_search: tool6({
+    description: `Search for projects within a specific group.
+Returns projects matching the search query within the specified group and its subgroups.
+
+Useful for:
+- Finding projects by name or description within a group
+- Discovering projects in large group hierarchies
+- Filtering group projects by keywords`,
+    args: {
+      group_id: z6.string().describe("The group ID or URL-encoded path"),
+      search: z6.string().describe("The search query (project name or description)"),
+      order_by: z6.enum(["created_at"]).optional().describe("Order results by created_at (default: created_at desc)"),
+      sort: z6.enum(["asc", "desc"]).optional().describe("Sort order (asc or desc)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.searchGroupProjects(args.group_id, args.search, {
+        order_by: args.order_by,
+        sort: args.sort,
+        limit: args.limit
+      });
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_milestone_search: tool6({
+    description: `Search for milestones in a project or across GitLab.
+Returns milestones matching the search query with details including title, description, state, and dates.
+
+Useful for:
+- Finding milestones by title or description
+- Discovering active or closed milestones
+- Planning and tracking project milestones`,
+    args: {
+      search: z6.string().describe("The search query (milestone title or description)"),
+      project_id: z6.string().optional().describe("Limit search to a specific project (optional)"),
+      state: z6.enum(["active", "closed", "all"]).optional().describe("Filter by milestone state"),
+      order_by: z6.enum(["created_at"]).optional().describe("Order results by created_at (default: created_at desc)"),
+      sort: z6.enum(["asc", "desc"]).optional().describe("Sort order (asc or desc)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.searchMilestones(args.search, args.project_id, {
+        state: args.state,
+        order_by: args.order_by,
+        sort: args.sort,
+        limit: args.limit
+      });
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_note_search: tool6({
+    description: `Search for notes/comments in a project.
+Returns notes (comments) matching the search query from issues, merge requests, commits, and snippets.
+
+Useful for:
+- Finding specific comments or discussions
+- Tracking feedback and review comments
+- Searching for mentions or keywords in conversations
+
+Note: This scope requires Premium or Ultimate tier with advanced search enabled.`,
+    args: {
+      search: z6.string().describe("The search query (comment text)"),
+      project_id: z6.string().describe("The project ID or URL-encoded path to search in"),
+      order_by: z6.enum(["created_at"]).optional().describe("Order results by created_at (default: created_at desc)"),
+      sort: z6.enum(["asc", "desc"]).optional().describe("Sort order (asc or desc)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.searchNotes(args.search, args.project_id, {
+        order_by: args.order_by,
+        sort: args.sort,
+        limit: args.limit
+      });
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_user_search: tool6({
+    description: `Search for users by name or email across GitLab.
+Returns users matching the search query with details including username, name, state, and avatar.
+
+Useful for:
+- Finding users to assign to issues or merge requests
+- Looking up user information by name or email
+- Discovering team members and collaborators`,
+    args: {
+      search: z6.string().describe("The search query (user name or email)"),
+      project_id: z6.string().optional().describe("Limit search to project members (optional)"),
+      order_by: z6.enum(["created_at"]).optional().describe("Order results by created_at (default: created_at desc)"),
+      sort: z6.enum(["asc", "desc"]).optional().describe("Sort order (asc or desc)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.searchUsers(args.search, args.project_id, {
+        order_by: args.order_by,
+        sort: args.sort,
+        limit: args.limit
+      });
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  gitlab_wiki_blob_search: tool6({
+    description: `Search for wiki content (blobs) in a project or across GitLab.
+Returns wiki pages matching the search query with content snippets and file information.
+
+Supports advanced filters (use in search query):
+- filename:some_name* - Filter by filename with wildcards
+- path:some/path* - Filter by path with wildcards
+- extension:md - Filter by file extension
+
+Examples:
+- "installation" - Search for "installation" in wiki content
+- "setup filename:getting-started*" - Search in files starting with "getting-started"
+- "api extension:md" - Search for "api" in markdown files
+
+Note: Advanced search (Premium/Ultimate) provides better wiki search capabilities.`,
+    args: {
+      search: z6.string().describe(
+        "The search query (supports filters: filename:, path:, extension: with wildcards)"
+      ),
+      project_id: z6.string().optional().describe("Limit search to a specific project (optional)"),
+      ref: z6.string().optional().describe("Branch or tag name to search on (defaults to default branch)"),
+      order_by: z6.enum(["created_at"]).optional().describe("Order results by created_at (default: created_at desc)"),
+      sort: z6.enum(["asc", "desc"]).optional().describe("Sort order (asc or desc)"),
+      limit: z6.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const results = await client.searchWikiBlobs(args.search, args.project_id, {
+        ref: args.ref,
+        order_by: args.order_by,
+        sort: args.sort,
+        limit: args.limit
+      });
+      return JSON.stringify(results, null, 2);
+    }
+  }),
+  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);
+    }
+  })
+};
+var userTools = {
+  gitlab_get_current_user: tool7({
+    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);
+    }
+  })
+};
+
+// src/tools/security.ts
+import { tool as tool8 } from "@opencode-ai/plugin";
+var z8 = tool8.schema;
+var securityTools = {
+  gitlab_list_vulnerabilities: tool8({
+    description: `List persisted vulnerabilities for a project.
+Returns security vulnerabilities detected in the project.`,
+    args: {
+      project_id: z8.string().describe("The project ID or URL-encoded path"),
+      state: z8.enum(["detected", "confirmed", "dismissed", "resolved"]).optional().describe("Filter by vulnerability state"),
+      severity: z8.enum(["undefined", "info", "unknown", "low", "medium", "high", "critical"]).optional().describe("Filter by severity level"),
+      report_type: z8.enum([
+        "sast",
+        "dast",
+        "dependency_scanning",
+        "container_scanning",
+        "secret_detection",
+        "coverage_fuzzing",
+        "api_fuzzing"
+      ]).optional().describe("Filter by report type"),
+      limit: z8.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: tool8({
+    description: `Get details for a specific vulnerability.
+Returns full information about a security vulnerability including description, location, and remediation.`,
+    args: {
+      project_id: z8.string().describe("The project ID or URL-encoded path"),
+      vulnerability_id: z8.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: tool8({
+    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: z8.string().describe('Full path of the project (e.g., "group/project" or "group/subgroup/project")'),
+      vulnerability_ids: z8.array(z8.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: tool8({
+    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: z8.string().describe(
+        'Vulnerability ID in format "gid://gitlab/Vulnerability/{id}". Get this from gitlab_list_vulnerabilities.'
+      ),
+      reason: z8.enum([
+        "ACCEPTABLE_RISK",
+        "FALSE_POSITIVE",
+        "MITIGATING_CONTROL",
+        "USED_IN_TESTS",
+        "NOT_APPLICABLE"
+      ]).describe("Reason for dismissing the vulnerability"),
+      comment: z8.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: tool8({
+    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: z8.string().describe(
+        'Vulnerability ID in format "gid://gitlab/Vulnerability/{id}". Get this from gitlab_list_vulnerabilities.'
+      ),
+      comment: z8.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: tool8({
+    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: z8.string().describe(
+        'Vulnerability ID in format "gid://gitlab/Vulnerability/{id}". Get this from gitlab_list_vulnerabilities.'
+      ),
+      comment: z8.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: tool8({
+    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: z8.array(z8.string()).describe(
+        'Array of vulnerability IDs in format "gid://gitlab/Vulnerability/{id}". Get these from gitlab_list_vulnerabilities.'
+      ),
+      severity: z8.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO", "UNKNOWN"]).describe("New severity level for the vulnerabilities"),
+      comment: z8.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: tool8({
+    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: z8.string().describe(
+        'Issue ID in format "gid://gitlab/Issue/{id}". You can construct this from the issue IID.'
+      ),
+      vulnerability_ids: z8.array(z8.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/snippets.ts
+import { tool as tool9 } from "@opencode-ai/plugin";
+var z9 = tool9.schema;
+var snippetTools = {
+  gitlab_list_snippet_discussions: tool9({
+    description: `List discussions (comment threads) on a project snippet.
+Returns all discussion threads with nested notes. Each discussion contains a 'notes' array with individual comments.
+Use the discussion 'id' field to reply to a specific thread with gitlab_create_snippet_note.`,
+    args: {
+      project_id: z9.string().describe("The project ID or URL-encoded path"),
+      snippet_id: z9.number().describe("The ID of the snippet")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussions = await client.listSnippetDiscussions(args.project_id, args.snippet_id);
+      return JSON.stringify(discussions, null, 2);
+    }
+  }),
+  gitlab_get_snippet_discussion: tool9({
+    description: `Get a specific discussion thread from a snippet with all its replies.
+Returns the discussion with its 'notes' array containing all comments in the thread.
+Use this to get the full context of a specific conversation.`,
+    args: {
+      project_id: z9.string().describe("The project ID or URL-encoded path"),
+      snippet_id: z9.number().describe("The ID of the snippet"),
+      discussion_id: z9.string().describe("The ID of the discussion thread")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.getSnippetDiscussion(
+        args.project_id,
+        args.snippet_id,
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  }),
+  gitlab_list_snippet_notes: tool9({
+    description: `List all notes/comments on a project snippet in a flat structure.
+Returns all comments including system notes in chronological order.`,
+    args: {
+      project_id: z9.string().describe("The project ID or URL-encoded path"),
+      snippet_id: z9.number().describe("The ID of the snippet")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const notes = await client.listSnippetNotes(args.project_id, args.snippet_id);
+      return JSON.stringify(notes, null, 2);
+    }
+  }),
+  gitlab_create_snippet_note: tool9({
+    description: `Add a comment/note to a project snippet.
+If discussion_id is provided, the note will be added as a reply to an existing discussion thread.
+Use gitlab_list_snippet_discussions to find discussion IDs for existing threads.`,
+    args: {
+      project_id: z9.string().describe("The project ID or URL-encoded path"),
+      snippet_id: z9.number().describe("The ID of the snippet"),
+      body: z9.string().describe("The content of the note/comment (supports Markdown)"),
+      discussion_id: z9.string().optional().describe(
+        "The ID of a discussion thread to reply to. If provided, the note will be added as a reply to that discussion."
+      )
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const note = await client.createSnippetNote(
+        args.project_id,
+        args.snippet_id,
+        args.body,
+        args.discussion_id
+      );
+      return JSON.stringify(note, null, 2);
+    }
+  }),
+  gitlab_create_snippet_discussion: tool9({
+    description: `Start a new discussion thread on a project snippet.
+Creates a new discussion with an initial comment.`,
+    args: {
+      project_id: z9.string().describe("The project ID or URL-encoded path"),
+      snippet_id: z9.number().describe("The ID of the snippet"),
+      body: z9.string().describe("The content of the initial comment (supports Markdown)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.createSnippetDiscussion(
+        args.project_id,
+        args.snippet_id,
+        args.body
+      );
+      return JSON.stringify(discussion, 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.
+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.`,
+    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"]).optional().describe("Filter by target type"),
+      limit: z10.number().optional().describe("Maximum number of results (default: 20)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const todos = 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,
+        limit: args.limit
+      });
+      return JSON.stringify(todos, null, 2);
+    }
+  }),
+  gitlab_mark_todo_done: tool10({
+    description: `Mark a specific TODO item as done.
+Use this to mark a single TODO as completed.`,
+    args: {
+      todo_id: z10.number().describe("The ID of the TODO item to mark as done")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const result = await client.markTodoAsDone(args.todo_id);
+      return JSON.stringify(result, null, 2);
+    }
+  }),
+  gitlab_mark_all_todos_done: tool10({
+    description: `Mark all TODO items as done.
+Use this to mark all pending TODOs for the current user as completed.`,
+    args: {},
+    execute: async (_args, _ctx) => {
+      const client = getGitLabClient();
+      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.ts
+import { tool as tool13 } from "@opencode-ai/plugin";
+var z13 = tool13.schema;
+var discussionTools = {
+  gitlab_reply_to_discussion: tool13({
+    description: `Universal tool for replying to any discussion thread across GitLab resources.
+Supports replying to discussions on: merge requests, issues, epics, commits, and snippets.
+This provides a consistent interface for thread replies regardless of the resource type.`,
+    args: {
+      resource_type: z13.enum(["merge_request", "issue", "epic", "commit", "snippet"]).describe("The type of resource the discussion belongs to"),
+      project_id: z13.string().optional().describe("The project ID or URL-encoded path (required for all except epic)"),
+      group_id: z13.string().optional().describe("The group ID or URL-encoded path (required for epic)"),
+      iid: z13.number().optional().describe("The internal ID of the resource (required for merge_request, issue, epic)"),
+      sha: z13.string().optional().describe("The commit SHA (required for commit)"),
+      snippet_id: z13.number().optional().describe("The snippet ID (required for snippet)"),
+      discussion_id: z13.string().describe("The ID of the discussion thread to reply to"),
+      body: z13.string().describe("The content of the reply (supports Markdown)")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      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);
+    }
+  }),
+  gitlab_get_discussion: tool13({
+    description: `Universal tool for fetching discussion details from any GitLab resource.
+Supports getting discussions from: merge requests, issues, epics, commits, and snippets.
+Returns the discussion with its 'notes' array containing all comments in the thread.`,
+    args: {
+      resource_type: z13.enum(["merge_request", "issue", "epic", "commit", "snippet"]).describe("The type of resource the discussion belongs to"),
+      project_id: z13.string().optional().describe("The project ID or URL-encoded path (required for all except epic)"),
+      group_id: z13.string().optional().describe("The group ID or URL-encoded path (required for epic)"),
+      iid: z13.number().optional().describe("The internal ID of the resource (required for merge_request, issue, epic)"),
+      sha: z13.string().optional().describe("The commit SHA (required for commit)"),
+      snippet_id: z13.number().optional().describe("The snippet ID (required for snippet)"),
+      discussion_id: z13.string().describe("The ID of the discussion thread to fetch")
+    },
+    execute: async (args, _ctx) => {
+      const client = getGitLabClient();
+      const discussion = await client.getDiscussion(
+        args.resource_type,
+        {
+          projectId: args.project_id,
+          groupId: args.group_id,
+          iid: args.iid,
+          sha: args.sha,
+          snippetId: args.snippet_id
+        },
+        args.discussion_id
+      );
+      return JSON.stringify(discussion, null, 2);
+    }
+  })
+};
+
+// src/tools/git.ts
+import { tool as tool14 } 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 z14 = tool14.schema;
+var gitClient = null;
+function getGitClient() {
+  if (!gitClient) {
+    gitClient = new GitClient();
+  }
+  return gitClient;
+}
+var gitTools = {
+  run_git_command: tool14({
+    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: z14.string().describe('The git command to execute (without "git" prefix)'),
+      args: z14.array(z14.string()).optional().describe("Array of arguments for the git command (default: [])"),
+      working_directory: z14.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 tool15 } from "@opencode-ai/plugin";
+var z15 = tool15.schema;
+var auditTools = {
+  gitlab_list_project_audit_events: tool15({
+    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: z15.string().describe("The project ID or URL-encoded path"),
+      created_after: z15.string().optional().describe("Return audit events created after this date (ISO 8601 format)"),
+      created_before: z15.string().optional().describe("Return audit events created before this date (ISO 8601 format)"),
+      entity_type: z15.string().optional().describe('Filter by entity type (e.g., "User", "Project", "Group")'),
+      entity_id: z15.number().optional().describe("Filter by entity ID"),
+      author_id: z15.number().optional().describe("Filter by author user ID"),
+      per_page: z15.number().optional().describe("Number of results per page (default: 20)"),
+      page: z15.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: tool15({
+    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: z15.string().describe("The group ID or URL-encoded path"),
+      created_after: z15.string().optional().describe("Return audit events created after this date (ISO 8601 format)"),
+      created_before: z15.string().optional().describe("Return audit events created before this date (ISO 8601 format)"),
+      entity_type: z15.string().optional().describe('Filter by entity type (e.g., "User", "Project", "Group")'),
+      entity_id: z15.number().optional().describe("Filter by entity ID"),
+      author_id: z15.number().optional().describe("Filter by author user ID"),
+      per_page: z15.number().optional().describe("Number of results per page (default: 20)"),
+      page: z15.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: tool15({
+    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: z15.string().optional().describe("Return audit events created after this date (ISO 8601 format)"),
+      created_before: z15.string().optional().describe("Return audit events created before this date (ISO 8601 format)"),
+      entity_type: z15.string().optional().describe('Filter by entity type (e.g., "User", "Project", "Group")'),
+      entity_id: z15.number().optional().describe("Filter by entity ID"),
+      author_id: z15.number().optional().describe("Filter by author user ID"),
+      per_page: z15.number().optional().describe("Number of results per page (default: 20)"),
+      page: z15.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/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,
+      // Snippet Tools
+      ...snippetTools,
+      // TODO Tools
+      ...todoTools,
+      // Wiki Tools
+      ...wikiTools,
+      // Work Item Tools
+      ...workItemTools,
+      // Commit Discussion Tools
+      ...commitDiscussionTools,
+      // Universal Discussion Tools
+      ...discussionTools,
+      // Git Tools
+      ...gitTools,
+      // Audit Tools
+      ...auditTools
+    }
+  };
+};
+var index_default = gitlabPlugin;
+export {
+  index_default as default,
+  gitlabPlugin
+};