[pr-66] fix: make old_line and new_line optional for image diff discussions

🐛 Bug Fix:
- Image files in GitLab MR discussions use x/y coordinates instead of line numbers
- Fixed schema validation error when fetching discussions on image files

📝 Details:
- Changed old_line and new_line from required to optional in GitLabDiscussionNoteSchema
- Allows proper handling of image diff comments that use position_type: 'image'

.env.example

@@ -0,0 +1,13 @@
+# GitLab API Configuration
+GITLAB_API_URL=https://gitlab.com
+GITLAB_TOKEN=your-gitlab-personal-access-token-here
+
+# Test Configuration (for integration tests)
+GITLAB_TOKEN_TEST=your-test-token-here
+TEST_PROJECT_ID=your-test-project-id
+ISSUE_IID=1
+
+# Proxy Configuration (optional)
+HTTP_PROXY=
+HTTPS_PROXY=
+NO_PROXY=localhost,127.0.0.1

.eslintrc.json

@@ -0,0 +1,24 @@
+{
+  "parser": "@typescript-eslint/parser",
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+  "plugins": ["@typescript-eslint"],
+  "parserOptions": {
+    "ecmaVersion": 2022,
+    "sourceType": "module"
+  },
+  "env": {
+    "node": true,
+    "es2022": true,
+    "jest": true
+  },
+  "rules": {
+    "no-console": "warn",
+    "prefer-const": "error",
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
+    "@typescript-eslint/explicit-module-boundary-types": "off",
+    "@typescript-eslint/no-explicit-any": "warn",
+    "@typescript-eslint/no-non-null-assertion": "warn"
+  },
+  "ignorePatterns": ["node_modules/", "build/", "coverage/", "*.js"]
+}

.github/pr-validation-guide.md

@@ -0,0 +1,96 @@
+# PR Validation Guide
+
+## Overview
+
+All Pull Requests are now automatically tested and validated. Manual testing is no longer required!
+
+## Automated Validation Items
+
+### 1. Build and Type Check
+
+- TypeScript compilation success
+- No type errors
+
+### 2. Testing
+
+- **Unit Tests**: API endpoints, error handling, authentication, etc.
+- **Integration Tests**: Real GitLab API integration (when environment variables are set)
+- **Code Coverage**: Test coverage report generation
+
+### 3. Code Quality
+
+- **ESLint**: Code style and potential bug detection
+- **Prettier**: Code formatting consistency
+- **Security Audit**: npm package vulnerability scanning
+
+### 4. Docker Build
+
+- Dockerfile build success
+- Container startup validation
+
+### 5. Node.js Version Compatibility
+
+- Tested across Node.js 18.x, 20.x, and 22.x
+
+## GitHub Secrets Setup (Optional)
+
+To enable integration tests, configure these secrets:
+
+1. `GITLAB_TOKEN_TEST`: GitLab Personal Access Token
+2. `TEST_PROJECT_ID`: Test GitLab project ID
+3. `GITLAB_API_URL`: GitLab API URL (default: https://gitlab.com)
+
+## Running Validation Locally
+
+You can run validation locally before submitting a PR:
+
+```bash
+# Run all validations
+./scripts/validate-pr.sh
+
+# Run individual validations
+npm run test           # All tests
+npm run test:unit      # Unit tests only
+npm run test:coverage  # With coverage
+npm run lint          # ESLint
+npm run format:check  # Prettier check
+```
+
+## PR Status Checks
+
+When you create a PR, these checks run automatically:
+
+- ✅ test (18.x)
+- ✅ test (20.x)
+- ✅ test (22.x)
+- ✅ integration-test
+- ✅ code-quality
+- ✅ coverage
+
+All checks must pass before merging is allowed.
+
+## Troubleshooting
+
+### Test Failures
+
+1. Check the failed test in the PR's "Checks" tab
+2. Review specific error messages in the logs
+3. Run the test locally to debug
+
+### Formatting Errors
+
+```bash
+npm run format      # Auto-fix formatting
+npm run lint:fix    # Auto-fix ESLint issues
+```
+
+### Type Errors
+
+```bash
+npx tsc --noEmit    # Run type check only
+```
+
+## Dependabot Auto-merge
+
+- Minor and patch updates are automatically merged
+- Major updates require manual review

.github/workflows/auto-merge.yml

@@ -0,0 +1,30 @@
+name: Auto Merge Dependabot PRs
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  auto-merge:
+    runs-on: ubuntu-latest
+    if: github.actor == 'dependabot[bot]'
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Dependabot metadata
+      id: metadata
+      uses: dependabot/fetch-metadata@v2
+      with:
+        github-token: "${{ secrets.GITHUB_TOKEN }}"
+    
+    - name: Auto-merge minor updates
+      if: steps.metadata.outputs.update-type == 'version-update:semver-minor' || steps.metadata.outputs.update-type == 'version-update:semver-patch'
+      run: gh pr merge --auto --merge "${{ github.event.pull_request.number }}"
+      env:
+        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/docker-publish.yml

@@ -0,0 +1,38 @@
+name: Docker Publish
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      
+      - name: Extract metadata for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/gitlab-mcp
+          tags: |
+            type=semver,pattern={{version}}
+            latest
+      
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}

.github/workflows/pr-test.yml

@@ -0,0 +1,163 @@
+name: PR Test and Validation
+
+on:
+  pull_request:
+    branches: [ main ]
+    types: [opened, synchronize, reopened]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x, 22.x]
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Setup Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    
+    - name: Install dependencies
+      run: npm ci
+    
+    - name: Build project
+      run: npm run build
+    
+    - name: Run tests
+      run: npm test
+      env:
+        GITLAB_API_URL: ${{ secrets.GITLAB_API_URL }}
+        GITLAB_TOKEN: ${{ secrets.GITLAB_TOKEN_TEST }}
+        GITLAB_PERSONAL_ACCESS_TOKEN: ${{ secrets.GITLAB_PERSONAL_ACCESS_TOKEN }}
+    
+    - name: Type check
+      run: npx tsc --noEmit
+    
+    - name: Lint check
+      run: npm run lint || echo "No lint script found"
+    
+    - name: Check package size
+      run: |
+        npm pack --dry-run
+        echo "Package created successfully"
+    
+    - name: Security audit
+      run: npm audit --production || echo "Some vulnerabilities found"
+      continue-on-error: true
+    
+    - name: Test MCP server startup
+      run: |
+        echo "MCP server startup test temporarily disabled for debugging"
+        echo "GITLAB_PERSONAL_ACCESS_TOKEN is: ${GITLAB_PERSONAL_ACCESS_TOKEN:0:10}..."
+      env:
+        GITLAB_API_URL: ${{ secrets.GITLAB_API_URL }}
+        GITLAB_TOKEN: ${{ secrets.GITLAB_TOKEN_TEST }}
+        GITLAB_PERSONAL_ACCESS_TOKEN: ${{ secrets.GITLAB_PERSONAL_ACCESS_TOKEN }}
+
+  integration-test:
+    runs-on: ubuntu-latest
+    needs: test
+    if: github.event.pull_request.draft == false
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+        cache: 'npm'
+    
+    - name: Install dependencies
+      run: npm ci
+    
+    - name: Build project
+      run: npm run build
+    
+    - name: Run integration tests
+      if: ${{ github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository }}
+      run: |
+        echo "Running integration tests with real GitLab API..."
+        npm run test:integration || echo "No integration test script found"
+      env:
+        GITLAB_API_URL: ${{ secrets.GITLAB_API_URL }}
+        GITLAB_TOKEN: ${{ secrets.GITLAB_TOKEN_TEST }}
+        GITLAB_PERSONAL_ACCESS_TOKEN: ${{ secrets.GITLAB_PERSONAL_ACCESS_TOKEN }}
+        PROJECT_ID: ${{ secrets.TEST_PROJECT_ID }}
+    
+    - name: Test Docker build
+      run: |
+        docker build -t mcp-gitlab-test .
+        docker run --rm mcp-gitlab-test node build/index.js --version || echo "Version check passed"
+
+  code-quality:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+        cache: 'npm'
+    
+    - name: Install dependencies
+      run: npm ci
+    
+    - name: Check code formatting
+      run: |
+        npx prettier --check "**/*.{js,ts,json,md}" || echo "Some files need formatting"
+    
+    - name: Check for console.log statements
+      run: |
+        if grep -r "console\.log" --include="*.ts" --exclude-dir=node_modules --exclude-dir=build --exclude="test*.ts" .; then
+          echo "⚠️ Found console.log statements in source code"
+        else
+          echo "✅ No console.log statements found"
+        fi
+    
+    - name: Check for TODO comments
+      run: |
+        if grep -r "TODO\|FIXME\|XXX" --include="*.ts" --exclude-dir=node_modules --exclude-dir=build .; then
+          echo "⚠️ Found TODO/FIXME comments"
+        else
+          echo "✅ No TODO/FIXME comments found"
+        fi
+
+  coverage:
+    runs-on: ubuntu-latest
+    if: github.event.pull_request.draft == false
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+        cache: 'npm'
+    
+    - name: Install dependencies
+      run: npm ci
+    
+    - name: Build project
+      run: npm run build
+    
+    - name: Run tests
+      run: npm test
+      env:
+        GITLAB_API_URL: ${{ secrets.GITLAB_API_URL }}
+        GITLAB_TOKEN_TEST: ${{ secrets.GITLAB_TOKEN_TEST }}
+        TEST_PROJECT_ID: ${{ secrets.TEST_PROJECT_ID }}

.gitignore

@@ -1,2 +1,8 @@
 node_modules
-.DS_Store
+.DS_Store
+build
+.env
+.env.local
+.env.test
+coverage/
+*.log

.prettierignore

@@ -0,0 +1,6 @@
+node_modules/
+build/
+coverage/
+*.log
+.DS_Store
+package-lock.json

.prettierrc

@@ -0,0 +1,11 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": false,
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false,
+  "bracketSpacing": true,
+  "arrowParens": "avoid",
+  "endOfLine": "lf"
+}

.secrets

@@ -0,0 +1,3 @@
+DOCKERHUB_USERNAME=DOCKERHUB_USERNAME
+DOCKERHUB_TOKEN=DOCKERHUB_TOKEN
+GITHUB_TOKEN=DOCKERHUB_TOKEN

CHANGELOG.md

@@ -0,0 +1,91 @@
+## [1.0.48] - 2025-05-29
+
+### Added
+
+- 🎯 **Milestone Management Tools**: Added comprehensive milestone management functionality
+  - `create_milestone`: Create new milestones for GitLab projects
+  - `update_milestone`: Update existing milestone properties (title, description, dates, state)
+  - `delete_milestone`: Delete milestones from projects
+  - `list_milestones`: List and filter project milestones
+  - `get_milestone`: Get detailed information about specific milestones
+  - See: [PR #59](https://github.com/zereight/gitlab-mcp/pull/59)
+
+### Fixed
+
+- 🐳 **Docker Image Push Script**: Added automated Docker image push script for easier deployment
+  - Simplifies the Docker image build and push process
+  - See: [PR #60](https://github.com/zereight/gitlab-mcp/pull/60)
+
+---
+
+## [1.0.47] - 2025-05-29
+
+### Added
+
+- 🔄 **List Merge Requests Tool**: Added functionality to list and filter merge requests in GitLab projects
+  - `list_merge_requests`: List merge requests with comprehensive filtering options
+  - Supports filtering by state, scope, author, assignee, reviewer, labels, and more
+  - Includes pagination support for large result sets
+  - See: [PR #56](https://github.com/zereight/gitlab-mcp/pull/56)
+
+### Fixed
+
+- Fixed issue where GitLab users without profile pictures would cause JSON-RPC errors
+
+  - Changed `avatar_url` field to be nullable in GitLabUserSchema
+  - This allows proper handling of users without avatars in GitLab API responses
+  - See: [PR #55](https://github.com/zereight/gitlab-mcp/pull/55)
+
+- Fixed issue where GitLab pipelines without illustrations would cause JSON-RPC errors
+  - Changed `illustration` field to be nullable in GitLabPipelineSchema
+  - This allows proper handling of pipelines without illustrations
+  - See: [PR #58](https://github.com/zereight/gitlab-mcp/pull/58), [Issue #57](https://github.com/zereight/gitlab-mcp/issues/57)
+
+---
+
+## [1.0.46] - 2025-05-27
+
+### Fixed
+
+- Fixed issue where GitLab issues and milestones with null descriptions would cause JSON-RPC errors
+  - Changed `description` field to be nullable with default empty string in schemas
+  - This allows proper handling of GitLab issues/milestones without descriptions
+  - See: [PR #53](https://github.com/zereight/gitlab-mcp/pull/53), [Issue #51](https://github.com/zereight/gitlab-mcp/issues/51)
+
+---
+
+## [1.0.45] - 2025-05-24
+
+### Added
+
+- 🔄 **Pipeline Management Tools**: Added GitLab pipeline status monitoring and management functionality
+  - `list_pipelines`: List project pipelines with various filtering options
+  - `get_pipeline`: Get detailed information about a specific pipeline
+  - `list_pipeline_jobs`: List all jobs in a specific pipeline
+  - `get_pipeline_job`: Get detailed information about a specific pipeline job
+  - `get_pipeline_job_output`: Get execution logs/output from pipeline jobs
+- 📊 Pipeline status summary and analysis support
+  - Example: "How many of the last N pipelines are successful?"
+  - Example: "Can you make a summary of the output in the last pipeline?"
+- See: [PR #52](https://github.com/zereight/gitlab-mcp/pull/52)
+
+---
+
+## [1.0.42] - 2025-05-22
+
+### Added
+
+- Added support for creating and updating issue notes (comments) in GitLab.
+- You can now add or edit comments on issues.
+- See: [PR #47](https://github.com/zereight/gitlab-mcp/pull/47)
+
+---
+
+## [1.0.38] - 2025-05-17
+
+### Fixed
+
+- Added `expanded` property to `start` and `end` in `GitLabDiscussionNoteSchema`  
+  Now you can expand or collapse more information at the start and end of discussion notes.  
+  Example: In code review, you can choose to show or hide specific parts of the discussion.  
+  (See: [PR #40](https://github.com/zereight/gitlab-mcp/pull/40))

Dockerfile

@@ -1,37 +1,24 @@
-# Generated by https://smithery.ai. See: https://smithery.ai/docs/config#dockerfile
-# Use an official Node.js image as the base image
-FROM node:16-alpine AS builder
+FROM node:22.15-alpine AS builder
+
+COPY . /app
+COPY tsconfig.json /tsconfig.json
 
-# Set the working directory
 WORKDIR /app
 
-# Copy package.json and package-lock.json files
-COPY package.json package-lock.json ./
+RUN --mount=type=cache,target=/root/.npm npm install
 
-# Install dependencies
-RUN npm install --ignore-scripts
+RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
 
-# Copy the rest of the application code
-COPY . .
+FROM node:22.12-alpine AS release
 
-# Build the application
-RUN npm run build
-
-# Use a smaller image for the runtime
-FROM node:16-alpine AS runner
-
-# Set the working directory
 WORKDIR /app
 
-# Copy the build output and package.json
-COPY --from=builder /app/build ./build
-COPY --from=builder /app/package.json ./
+COPY --from=builder /app/build /app/build
+COPY --from=builder /app/package.json /app/package.json
+COPY --from=builder /app/package-lock.json /app/package-lock.json
 
-# Set environment variables
-ENV GITLAB_API_URL=https://gitlab.com/api/v4
+ENV NODE_ENV=production
 
-# Define the command to run the application
-ENTRYPOINT ["node", "build/index.js"]
+RUN npm ci --ignore-scripts --omit-dev
 
-# This image requires the following environment variable at runtime:
-# - GITLAB_PERSONAL_ACCESS_TOKEN: Your GitLab personal access token
+ENTRYPOINT ["node", "build/index.js"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Roo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -10,10 +10,12 @@ GitLab MCP(Model Context Protocol) Server. **Includes bug fixes and improvements
 
 ## Usage
 
-### Using with Claude App, Cline, Roo Code
+### Using with Claude App, Cline, Roo Code, Cursor
 
 When using with the Claude App, you need to set up your API key and URLs directly.
 
+#### npx
+
 ```json
 {
   "mcpServers": {
@@ -22,258 +24,135 @@ When using with the Claude App, you need to set up your API key and URLs directl
       "args": ["-y", "@zereight/mcp-gitlab"],
       "env": {
         "GITLAB_PERSONAL_ACCESS_TOKEN": "your_gitlab_token",
-        "GITLAB_API_URL": "your_gitlab_api_url"
+        "GITLAB_API_URL": "your_gitlab_api_url",
+        "GITLAB_READ_ONLY_MODE": "false",
+        "USE_GITLAB_WIKI": "false", // use wiki api?
+        "USE_MILESTONE": "false", // use milestone api?
+        "USE_PIPELINE": "false" // use pipeline api?
       }
     }
   }
 }
 ```
 
-### Using with Cursor
+#### Docker
 
-When using with Cursor, you can set up environment variables and run the server as follows:
+```json
+{
+  "mcpServers": {
+    "GitLab communication server": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "-e",
+        "GITLAB_PERSONAL_ACCESS_TOKEN",
+        "-e",
+        "GITLAB_API_URL",
+        "-e",
+        "GITLAB_READ_ONLY_MODE",
+        "-e",
+        "USE_GITLAB_WIKI",
+        "-e",
+        "USE_MILESTONE",
+        "-e",
+        "USE_PIPELINE",
+        "iwakitakuma/gitlab-mcp"
+      ],
+      "env": {
+        "GITLAB_PERSONAL_ACCESS_TOKEN": "your_gitlab_token",
+        "GITLAB_API_URL": "https://gitlab.com/api/v4", // Optional, for self-hosted GitLab
+        "GITLAB_READ_ONLY_MODE": "false",
+        "USE_GITLAB_WIKI": "true",
+        "USE_MILESTONE": "true",
+        "USE_PIPELINE": "true"
+      }
+    }
+  }
+}
+```
 
+#### Docker Image Push
+
+```shell
+$ sh scripts/image_push.sh docker_user_name
 ```
-env GITLAB_PERSONAL_ACCESS_TOKEN=your_gitlab_token GITLAB_API_URL=your_gitlab_api_url npx @zereight/mcp-gitlab
-```
+
+### Environment Variables
 
 - `GITLAB_PERSONAL_ACCESS_TOKEN`: Your GitLab personal access token.
 - `GITLAB_API_URL`: Your GitLab API URL. (Default: `https://gitlab.com/api/v4`)
+- `GITLAB_READ_ONLY_MODE`: When set to 'true', restricts the server to only expose read-only operations. Useful for enhanced security or when write access is not needed. Also useful for using with Cursor and it's 40 tool limit.
+- `USE_GITLAB_WIKI`: When set to 'true', enables the wiki-related tools (list_wiki_pages, get_wiki_page, create_wiki_page, update_wiki_page, delete_wiki_page). By default, wiki features are disabled.
+- `USE_MILESTONE`: When set to 'true', enables the milestone-related tools (list_milestones, get_milestone, create_milestone, edit_milestone, delete_milestone, get_milestone_issue, get_milestone_merge_requests, promote_milestone, get_milestone_burndown_events). By default, milestone features are disabled.
+- `USE_PIPELINE`: When set to 'true', enables the pipeline-related tools (list_pipelines, get_pipeline, list_pipeline_jobs, get_pipeline_job, get_pipeline_job_output, create_pipeline, retry_pipeline, cancel_pipeline). By default, pipeline features are disabled.
 
 ## Tools 🛠️
 
-1. `create_or_update_file`
++<!-- TOOLS-START -->
 
-   - Create or update a single file in a GitLab project. 📝
-   - Inputs:
-     - `project_id` (string): Project ID or namespace/project_path
-     - `file_path` (string): Path to create/update the file
-     - `content` (string): File content
-     - `commit_message` (string): Commit message
-     - `branch` (string): Branch to create/update the file in
-     - `previous_path` (optional string): Previous file path when renaming a file
-   - Returns: File content and commit details
-
-2. `push_files`
-
-   - Push multiple files in a single commit. 📤
-   - Inputs:
-     - `project_id` (string): Project ID or namespace/project_path
-     - `branch` (string): Branch to push to
-     - `files` (array): Array of files to push, each with `file_path` and `content` properties
-     - `commit_message` (string): Commit message
-   - Returns: Updated branch reference
-
-3. `search_repositories`
-
-   - Search for GitLab projects. 🔍
-   - Inputs:
-     - `search` (string): Search query
-     - `page` (optional number): Page number (default: 1)
-     - `per_page` (optional number): Results per page (default: 20, max: 100)
-   - Returns: Project search results
-
-4. `create_repository`
-
-   - Create a new GitLab project. ➕
-   - Inputs:
-     - `name` (string): Project name
-     - `description` (optional string): Project description
-     - `visibility` (optional string): Project visibility level (public, private, internal)
-     - `initialize_with_readme` (optional boolean): Initialize with README
-   - Returns: Details of the created project
-
-5. `get_file_contents`
-
-   - Get the contents of a file or directory. 📂
-   - Inputs:
-     - `project_id` (string): Project ID or namespace/project_path
-     - `file_path` (string): Path to the file/directory
-     - `ref` (optional string): Branch, tag, or commit SHA (default: default branch)
-   - Returns: File/directory content
-
-6. `create_issue`
-
-   - Create a new issue. 🐛
-   - Inputs:
-     - `project_id` (string): Project ID or namespace/project_path
-     - `title` (string): Issue title
-     - `description` (string): Issue description
-     - `assignee_ids` (optional number[]): Array of assignee IDs
-     - `milestone_id` (optional number): Milestone ID
-     - `labels` (optional string[]): Array of labels
-   - Returns: Details of the created issue
-
-7. `create_merge_request`
-
-   - Create a new merge request. 🚀
-   - Inputs:
-     - `project_id` (string): Project ID or namespace/project_path
-     - `title` (string): Merge request title
-     - `description` (string): Merge request description
-     - `source_branch` (string): Branch with changes
-     - `target_branch` (string): Branch to merge into
-     - `allow_collaboration` (optional boolean): Allow collaborators to push commits to the source branch
-     - `draft` (optional boolean): Create as a draft merge request
-   - Returns: Details of the created merge request
-
-8. `fork_repository`
-
-   - Fork a project. 🍴
-   - Inputs:
-     - `project_id` (string): Project ID or namespace/project_path to fork
-     - `namespace` (optional string): Namespace to fork into (default: user namespace)
-   - Returns: Details of the forked project
-
-9. `create_branch`
-
-   - Create a new branch. 🌿
-   - Inputs:
-     - `project_id` (string): Project ID or namespace/project_path
-     - `name` (string): New branch name
-     - `ref` (optional string): Ref to create the branch from (branch, tag, commit SHA, default: default branch)
-   - Returns: Created branch reference
-
-10. `get_merge_request`
-
-    - Get details of a merge request. ℹ️
-    - Inputs:
-      - `project_id` (string): Project ID or namespace/project_path
-      - `merge_request_iid` (number): Merge request IID
-    - Returns: Merge request details
-
-11. `get_merge_request_diffs`
-
-    - Get changes (diffs) of a merge request. diff
-    - Inputs:
-      - `project_id` (string): Project ID or namespace/project_path
-      - `merge_request_iid` (number): Merge request IID
-      - `view` (optional string): Diff view type ('inline' or 'parallel')
-    - Returns: Array of merge request diff information
-
-12. `update_merge_request`
-
-    - Update a merge request. 🔄
-    - Inputs:
-      - `project_id` (string): Project ID or namespace/project_path
-      - `merge_request_iid` (number): Merge request IID
-      - `title` (optional string): New title
-      - `description` (string): New description
-      - `target_branch` (optional string): New target branch
-      - `state_event` (optional string): Merge request state change event ('close', 'reopen')
-      - `remove_source_branch` (optional boolean): Remove source branch after merge
-      - `allow_collaboration` (optional boolean): Allow collaborators to push commits to the source branch
-    - Returns: Updated merge request details
-
-13. `create_note`
-    - Create a new note (comment) to an issue or merge request. 💬
-    - Inputs:
-      - `project_id` (string): Project ID or namespace/project_path
-      - `noteable_type` (string): Type of noteable ("issue" or "merge_request")
-      - `noteable_iid` (number): IID of the issue or merge request
-      - `body` (string): Note content
-    - Returns: Details of the created note
-
-14. `list_projects`
-    - List accessible projects with rich filtering options 📊
-    - Inputs:
-      - Search/filtering:
-        - `search`
-        - `owned`
-        - `membership`
-        - `archived`
-        - `visibility`
-      - Features filtering:
-        - `with_issues_enabled`
-        - `with_merge_requests_enabled`
-      - Sorting:
-        - `order_by`
-        - `sort`
-      - Access control:
-        - `min_access_level`
-      - Pagination:
-        - `page`
-        - `per_page`
-        - `simple`
-    - Returns: Array of projects 
-15. `list_labels`
-    - List all labels for a project with filtering options 🏷️
-    - Inputs:
-      - `project_id` (string): Project ID or path
-      - `with_counts` (optional): Include issue and merge request counts
-      - `include_ancestor_groups` (optional): Include ancestor groups
-      - `search` (optional): Filter labels by keyword
-    - Returns: Array of labels
-16. `get_label`
-    - Get a single label from a project
-    - Inputs:
-      -  `project_id` (string): Project ID or path
-      - `label_id` (number/string): Label ID or name
-      - `include_ancestor_groups` (optional): Include ancestor groups 
-    - Returns: label details
-17. `create_label`
-    - Create a new label in an object 🏷️➕
-    - Inputs:
-      - `project_id` (string): Project ID or path
-      - `name` (string): Label name
-      - `color` (string): Color in hex format (e.g., "#FF0000")
-      - `description` (optional): Label description
-      - `priority` (optional): Label priority
-    - Returns: Created label details
-18. `update_label`
-    - Update an existing label in a project 🏷️✏️
-    - Inputs:
-      - `project_id` (string): Project ID or path
-      - `label_id` (number/string): Label ID or name
-      - `new_name` (optional): New label name
-      - `color` (optional): New color in hex format
-      - `description` (optional): New description
-      - `priority` (optional): New priority
-    - Returns: Updated label details
-19. `delete_label`
-    - Delete a label from a project 🏷️❌
-    - Inputs:
-      - `project_id` (string): Project ID or path
-      - `label_id` (number/string): Label ID or name
-    - Returns: Success message
-
-14. `list_group_projects`
-
-    - List all projects in a GitLab group. 📂
-    - Inputs:
-      - `group_id` (string): Project ID or namespace/project_path
-      - Filtering options:
-        - `include_subgroups` (optional boolean): Include projects from subgroups
-        - `search` (optional string): Search term to filter projects
-        - `archived` (optional boolean): Filter for archived projects
-        - `visibility` (optional string): Filter by project visibility (public/internal/private)
-        - `with_programming_language` (optional string): Filter by programming language
-        - `starred` (optional boolean): Filter by starred projects
-      - Feature filtering:
-        - `with_issues_enabled` (optional boolean): Filter projects with issues feature enabled
-        - `with_merge_requests_enabled` (optional boolean): Filter projects with merge requests feature enabled
-        - `min_access_level` (optional number): Filter by minimum access level
-      - Pagination:
-        - `page` (optional number): Page number
-        - `per_page` (optional number): Results per page
-      - Sorting:
-        - `order_by` (optional string): Field to sort by
-        - `sort` (optional string): Sort direction (asc/desc)
-      - Additional data:
-        - `statistics` (optional boolean): Include project statistics
-        - `with_custom_attributes` (optional boolean): Include custom attributes
-        - `with_security_reports` (optional boolean): Include security reports
-    - Returns: List of projects
-
-## Environment Variable Configuration
-
-Before running the server, you need to set the following environment variables:
-
-```
-GITLAB_PERSONAL_ACCESS_TOKEN=your_gitlab_token
-GITLAB_API_URL=your_gitlab_api_url  # Default: https://gitlab.com/api/v4
-```
-
-## License
-
-MIT License
+1. `create_or_update_file` - Create or update a single file in a GitLab project
+2. `search_repositories` - Search for GitLab projects
+3. `create_repository` - Create a new GitLab project
+4. `get_file_contents` - Get the contents of a file or directory from a GitLab project
+5. `push_files` - Push multiple files to a GitLab project in a single commit
+6. `create_issue` - Create a new issue in a GitLab project
+7. `create_merge_request` - Create a new merge request in a GitLab project
+8. `fork_repository` - Fork a GitLab project to your account or specified namespace
+9. `create_branch` - Create a new branch in a GitLab project
+10. `get_merge_request` - Get details of a merge request (Either mergeRequestIid or branchName must be provided)
+11. `get_merge_request_diffs` - Get the changes/diffs of a merge request (Either mergeRequestIid or branchName must be provided)
+12. `update_merge_request` - Update a merge request (Either mergeRequestIid or branchName must be provided)
+13. `create_note` - Create a new note (comment) to an issue or merge request
+14. `create_merge_request_thread` - Create a new thread on a merge request
+15. `mr_discussions` - List discussion items for a merge request
+16. `update_merge_request_note` - Modify an existing merge request thread note
+17. `create_merge_request_note` - Add a new note to an existing merge request thread
+18. `update_issue_note` - Modify an existing issue thread note
+19. `create_issue_note` - Add a new note to an existing issue thread
+20. `list_issues` - List issues in a GitLab project with filtering options
+21. `get_issue` - Get details of a specific issue in a GitLab project
+22. `update_issue` - Update an issue in a GitLab project
+23. `delete_issue` - Delete an issue from a GitLab project
+24. `list_issue_links` - List all issue links for a specific issue
+25. `list_issue_discussions` - List discussions for an issue in a GitLab project
+26. `get_issue_link` - Get a specific issue link
+27. `create_issue_link` - Create an issue link between two issues
+28. `delete_issue_link` - Delete an issue link
+29. `list_namespaces` - List all namespaces available to the current user
+30. `get_namespace` - Get details of a namespace by ID or path
+31. `verify_namespace` - Verify if a namespace path exists
+32. `get_project` - Get details of a specific project
+33. `list_projects` - List projects accessible by the current user
+34. `list_labels` - List labels for a project
+35. `get_label` - Get a single label from a project
+36. `create_label` - Create a new label in a project
+37. `update_label` - Update an existing label in a project
+38. `delete_label` - Delete a label from a project
+39. `list_group_projects` - List projects in a GitLab group with filtering options
+40. `list_wiki_pages` - List wiki pages in a GitLab project
+41. `get_wiki_page` - Get details of a specific wiki page
+42. `create_wiki_page` - Create a new wiki page in a GitLab project
+43. `update_wiki_page` - Update an existing wiki page in a GitLab project
+44. `delete_wiki_page` - Delete a wiki page from a GitLab project
+45. `get_repository_tree` - Get the repository tree for a GitLab project (list files and directories)
+46. `list_pipelines` - List pipelines in a GitLab project with filtering options
+47. `get_pipeline` - Get details of a specific pipeline in a GitLab project
+48. `list_pipeline_jobs` - List all jobs in a specific pipeline
+49. `get_pipeline_job` - Get details of a GitLab pipeline job number
+50. `get_pipeline_job_output` - Get the output/trace of a GitLab pipeline job number
+51. `create_pipeline` - Create a new pipeline for a branch or tag
+52. `retry_pipeline` - Retry a failed or canceled pipeline
+53. `cancel_pipeline` - Cancel a running pipeline
+54. `list_merge_requests` - List merge requests in a GitLab project with filtering options
+55. `list_milestones` - List milestones in a GitLab project with filtering options
+56. `get_milestone` - Get details of a specific milestone
+57. `create_milestone` - Create a new milestone in a GitLab project
+58. `edit_milestone ` - Edit an existing milestone in a GitLab project
+59. `delete_milestone` - Delete a milestone from a GitLab project
+60. `get_milestone_issue` - Get issues associated with a specific milestone
+61. `get_milestone_merge_requests` - Get merge requests associated with a specific milestone
+62. `promote_milestone` - Promote a milestone to the next stage
+63. `get_milestone_burndown_events` - Get burndown events for a specific milestone
+<!-- TOOLS-END -->

build/schemas.js

@@ -1,684 +0,0 @@
-import { z } from "zod";
-// Base schemas for common types
-export const GitLabAuthorSchema = z.object({
-    name: z.string(),
-    email: z.string(),
-    date: z.string(),
-});
-// Namespace related schemas
-// Base schema for project-related operations
-const ProjectParamsSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"), // Changed from owner/repo to match GitLab API
-});
-export const GitLabNamespaceSchema = z.object({
-    id: z.number(),
-    name: z.string(),
-    path: z.string(),
-    kind: z.enum(["user", "group"]),
-    full_path: z.string(),
-    parent_id: z.number().nullable(),
-    avatar_url: z.string().nullable(),
-    web_url: z.string(),
-    members_count_with_descendants: z.number().optional(),
-    billable_members_count: z.number().optional(),
-    max_seats_used: z.number().optional(),
-    seats_in_use: z.number().optional(),
-    plan: z.string().optional(),
-    end_date: z.string().nullable().optional(),
-    trial_ends_on: z.string().nullable().optional(),
-    trial: z.boolean().optional(),
-    root_repository_size: z.number().optional(),
-    projects_count: z.number().optional(),
-});
-export const GitLabNamespaceExistsResponseSchema = z.object({
-    exists: z.boolean(),
-    suggests: z.array(z.string()).optional(),
-});
-// Repository related schemas
-export const GitLabOwnerSchema = z.object({
-    username: z.string(), // Changed from login to match GitLab API
-    id: z.number(),
-    avatar_url: z.string(),
-    web_url: z.string(), // Changed from html_url to match GitLab API
-    name: z.string(), // Added as GitLab includes full name
-    state: z.string(), // Added as GitLab includes user state
-});
-export const GitLabRepositorySchema = z.object({
-    id: z.number(),
-    name: z.string(),
-    path_with_namespace: z.string(),
-    visibility: z.string().optional(),
-    owner: GitLabOwnerSchema.optional(),
-    web_url: z.string().optional(),
-    description: z.string().nullable(),
-    fork: z.boolean().optional(),
-    ssh_url_to_repo: z.string().optional(),
-    http_url_to_repo: z.string().optional(),
-    created_at: z.string().optional(),
-    last_activity_at: z.string().optional(),
-    default_branch: z.string().optional(),
-    namespace: z.object({
-        id: z.number(),
-        name: z.string(),
-        path: z.string(),
-        kind: z.string(),
-        full_path: z.string(),
-        avatar_url: z.string().nullable().optional(),
-        web_url: z.string().optional(),
-    }).optional(),
-    readme_url: z.string().optional().nullable(),
-    topics: z.array(z.string()).optional(),
-    tag_list: z.array(z.string()).optional(), // deprecated but still present
-    open_issues_count: z.number().optional(),
-    archived: z.boolean().optional(),
-    forks_count: z.number().optional(),
-    star_count: z.number().optional(),
-    permissions: z.object({
-        project_access: z.object({
-            access_level: z.number(),
-            notification_level: z.number().optional(),
-        }).optional().nullable(),
-        group_access: z.object({
-            access_level: z.number(),
-            notification_level: z.number().optional(),
-        }).optional().nullable(),
-    }).optional(),
-    container_registry_enabled: z.boolean().optional(),
-    container_registry_access_level: z.string().optional(),
-    issues_enabled: z.boolean().optional(),
-    merge_requests_enabled: z.boolean().optional(),
-    wiki_enabled: z.boolean().optional(),
-    jobs_enabled: z.boolean().optional(),
-    snippets_enabled: z.boolean().optional(),
-    can_create_merge_request_in: z.boolean().optional(),
-    resolve_outdated_diff_discussions: z.boolean().optional(),
-    shared_runners_enabled: z.boolean().optional(),
-    shared_with_groups: z.array(z.object({
-        group_id: z.number(),
-        group_name: z.string(),
-        group_full_path: z.string(),
-        group_access_level: z.number(),
-    })).optional(),
-});
-// Project schema (extended from repository schema)
-export const GitLabProjectSchema = GitLabRepositorySchema;
-// File content schemas
-export const GitLabFileContentSchema = z.object({
-    file_name: z.string(), // Changed from name to match GitLab API
-    file_path: z.string(), // Changed from path to match GitLab API
-    size: z.number(),
-    encoding: z.string(),
-    content: z.string(),
-    content_sha256: z.string(), // Changed from sha to match GitLab API
-    ref: z.string(), // Added as GitLab requires branch reference
-    blob_id: z.string(), // Added to match GitLab API
-    commit_id: z.string(), // ID of the current file version
-    last_commit_id: z.string(), // Added to match GitLab API
-    execute_filemode: z.boolean().optional(), // Added to match GitLab API
-});
-export const GitLabDirectoryContentSchema = z.object({
-    name: z.string(),
-    path: z.string(),
-    type: z.string(),
-    mode: z.string(),
-    id: z.string(), // Changed from sha to match GitLab API
-    web_url: z.string(), // Changed from html_url to match GitLab API
-});
-export const GitLabContentSchema = z.union([
-    GitLabFileContentSchema,
-    z.array(GitLabDirectoryContentSchema),
-]);
-// Operation schemas
-export const FileOperationSchema = z.object({
-    path: z.string(),
-    content: z.string(),
-});
-// Tree and commit schemas
-export const GitLabTreeEntrySchema = z.object({
-    id: z.string(), // Changed from sha to match GitLab API
-    name: z.string(),
-    type: z.enum(["blob", "tree"]),
-    path: z.string(),
-    mode: z.string(),
-});
-export const GitLabTreeSchema = z.object({
-    id: z.string(), // Changed from sha to match GitLab API
-    tree: z.array(GitLabTreeEntrySchema),
-});
-export const GitLabCommitSchema = z.object({
-    id: z.string(), // Changed from sha to match GitLab API
-    short_id: z.string(), // Added to match GitLab API
-    title: z.string(), // Changed from message to match GitLab API
-    author_name: z.string(),
-    author_email: z.string(),
-    authored_date: z.string(),
-    committer_name: z.string(),
-    committer_email: z.string(),
-    committed_date: z.string(),
-    web_url: z.string(), // Changed from html_url to match GitLab API
-    parent_ids: z.array(z.string()), // Changed from parents to match GitLab API
-});
-// Reference schema
-export const GitLabReferenceSchema = z.object({
-    name: z.string(), // Changed from ref to match GitLab API
-    commit: z.object({
-        id: z.string(), // Changed from sha to match GitLab API
-        web_url: z.string(), // Changed from url to match GitLab API
-    }),
-});
-// Input schemas for operations
-export const CreateRepositoryOptionsSchema = z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    visibility: z.enum(["private", "internal", "public"]).optional(), // Changed from private to match GitLab API
-    initialize_with_readme: z.boolean().optional(), // Changed from auto_init to match GitLab API
-});
-export const CreateIssueOptionsSchema = z.object({
-    title: z.string(),
-    description: z.string().optional(), // Changed from body to match GitLab API
-    assignee_ids: z.array(z.number()).optional(), // Changed from assignees to match GitLab API
-    milestone_id: z.number().optional(), // Changed from milestone to match GitLab API
-    labels: z.array(z.string()).optional(),
-});
-export const CreateMergeRequestOptionsSchema = z.object({
-    // Changed from CreatePullRequestOptionsSchema
-    title: z.string(),
-    description: z.string().optional(), // Changed from body to match GitLab API
-    source_branch: z.string(), // Changed from head to match GitLab API
-    target_branch: z.string(), // Changed from base to match GitLab API
-    allow_collaboration: z.boolean().optional(), // Changed from maintainer_can_modify to match GitLab API
-    draft: z.boolean().optional(),
-});
-export const CreateBranchOptionsSchema = z.object({
-    name: z.string(), // Changed from ref to match GitLab API
-    ref: z.string(), // The source branch/commit for the new branch
-});
-// Response schemas for operations
-export const GitLabCreateUpdateFileResponseSchema = z.object({
-    file_path: z.string(),
-    branch: z.string(),
-    commit_id: z.string().optional(), // Optional since it's not always returned by the API
-    content: GitLabFileContentSchema.optional(),
-});
-export const GitLabSearchResponseSchema = z.object({
-    count: z.number().optional(),
-    total_pages: z.number().optional(),
-    current_page: z.number().optional(),
-    items: z.array(GitLabRepositorySchema),
-});
-// Issue related schemas
-export const GitLabLabelSchema = z.object({
-    id: z.number(),
-    name: z.string(),
-    color: z.string(),
-    text_color: z.string(),
-    description: z.string().nullable(),
-    description_html: z.string().nullable(),
-    open_issues_count: z.number().optional(),
-    closed_issues_count: z.number().optional(),
-    open_merge_requests_count: z.number().optional(),
-    subscribed: z.boolean().optional(),
-    priority: z.number().nullable().optional(),
-    is_project_label: z.boolean().optional(),
-});
-export const GitLabUserSchema = z.object({
-    username: z.string(), // Changed from login to match GitLab API
-    id: z.number(),
-    name: z.string(),
-    avatar_url: z.string(),
-    web_url: z.string(), // Changed from html_url to match GitLab API
-});
-export const GitLabMilestoneSchema = z.object({
-    id: z.number(),
-    iid: z.number(), // Added to match GitLab API
-    title: z.string(),
-    description: z.string(),
-    state: z.string(),
-    web_url: z.string(), // Changed from html_url to match GitLab API
-});
-export const GitLabIssueSchema = z.object({
-    id: z.number(),
-    iid: z.number(), // Added to match GitLab API
-    project_id: z.number(), // Added to match GitLab API
-    title: z.string(),
-    description: z.string(), // Changed from body to match GitLab API
-    state: z.string(),
-    author: GitLabUserSchema,
-    assignees: z.array(GitLabUserSchema),
-    labels: z.array(GitLabLabelSchema).or(z.array(z.string())), // Support both label objects and strings
-    milestone: GitLabMilestoneSchema.nullable(),
-    created_at: z.string(),
-    updated_at: z.string(),
-    closed_at: z.string().nullable(),
-    web_url: z.string(), // Changed from html_url to match GitLab API
-    references: z.object({
-        short: z.string(),
-        relative: z.string(),
-        full: z.string(),
-    }).optional(),
-    time_stats: z.object({
-        time_estimate: z.number(),
-        total_time_spent: z.number(),
-        human_time_estimate: z.string().nullable(),
-        human_total_time_spent: z.string().nullable(),
-    }).optional(),
-    confidential: z.boolean().optional(),
-    due_date: z.string().nullable().optional(),
-    discussion_locked: z.boolean().nullable().optional(),
-    weight: z.number().nullable().optional(),
-});
-// NEW SCHEMA: For issue with link details (used in listing issue links)
-export const GitLabIssueWithLinkDetailsSchema = GitLabIssueSchema.extend({
-    issue_link_id: z.number(),
-    link_type: z.enum(['relates_to', 'blocks', 'is_blocked_by']),
-    link_created_at: z.string(),
-    link_updated_at: z.string(),
-});
-// Fork related schemas
-export const GitLabForkParentSchema = z.object({
-    name: z.string(),
-    path_with_namespace: z.string(), // Changed from full_name to match GitLab API
-    owner: z.object({
-        username: z.string(), // Changed from login to match GitLab API
-        id: z.number(),
-        avatar_url: z.string(),
-    }).optional(), // Made optional to handle cases where GitLab API doesn't include it
-    web_url: z.string(), // Changed from html_url to match GitLab API
-});
-export const GitLabForkSchema = GitLabRepositorySchema.extend({
-    forked_from_project: GitLabForkParentSchema.optional(), // Made optional to handle cases where GitLab API doesn't include it
-});
-// Merge Request related schemas (equivalent to Pull Request)
-export const GitLabMergeRequestDiffRefSchema = z.object({
-    base_sha: z.string(),
-    head_sha: z.string(),
-    start_sha: z.string(),
-});
-export const GitLabMergeRequestSchema = z.object({
-    id: z.number(),
-    iid: z.number(),
-    project_id: z.number(),
-    title: z.string(),
-    description: z.string().nullable(),
-    state: z.string(),
-    merged: z.boolean().optional(),
-    draft: z.boolean().optional(),
-    author: GitLabUserSchema,
-    assignees: z.array(GitLabUserSchema).optional(),
-    source_branch: z.string(),
-    target_branch: z.string(),
-    diff_refs: GitLabMergeRequestDiffRefSchema.nullable().optional(),
-    web_url: z.string(),
-    created_at: z.string(),
-    updated_at: z.string(),
-    merged_at: z.string().nullable(),
-    closed_at: z.string().nullable(),
-    merge_commit_sha: z.string().nullable(),
-    detailed_merge_status: z.string().optional(),
-    merge_status: z.string().optional(),
-    merge_error: z.string().nullable().optional(),
-    work_in_progress: z.boolean().optional(),
-    blocking_discussions_resolved: z.boolean().optional(),
-    should_remove_source_branch: z.boolean().nullable().optional(),
-    force_remove_source_branch: z.boolean().nullable().optional(),
-    allow_collaboration: z.boolean().optional(),
-    allow_maintainer_to_push: z.boolean().optional(),
-    changes_count: z.string().nullable().optional(),
-    merge_when_pipeline_succeeds: z.boolean().optional(),
-    squash: z.boolean().optional(),
-    labels: z.array(z.string()).optional(),
-});
-// Discussion related schemas
-export const GitLabDiscussionNoteSchema = z.object({
-    id: z.number(),
-    type: z.enum(["DiscussionNote", "DiffNote", "Note"]).nullable(), // Allow null type for regular notes
-    body: z.string(),
-    attachment: z.any().nullable(), // Can be string or object, handle appropriately
-    author: GitLabUserSchema,
-    created_at: z.string(),
-    updated_at: z.string(),
-    system: z.boolean(),
-    noteable_id: z.number(),
-    noteable_type: z.enum(["Issue", "MergeRequest", "Snippet", "Commit", "Epic"]),
-    project_id: z.number().optional(), // Optional for group-level discussions like Epics
-    noteable_iid: z.number().nullable(),
-    resolvable: z.boolean().optional(),
-    resolved: z.boolean().optional(),
-    resolved_by: GitLabUserSchema.nullable().optional(),
-    resolved_at: z.string().nullable().optional(),
-    position: z.object({
-        base_sha: z.string(),
-        start_sha: z.string(),
-        head_sha: z.string(),
-        old_path: z.string(),
-        new_path: z.string(),
-        position_type: z.enum(["text", "image", "file"]),
-        old_line: z.number().nullable(),
-        new_line: z.number().nullable(),
-        line_range: z.object({
-            start: z.object({
-                line_code: z.string(),
-                type: z.enum(["new", "old"]),
-                old_line: z.number().nullable(),
-                new_line: z.number().nullable(),
-            }),
-            end: z.object({
-                line_code: z.string(),
-                type: z.enum(["new", "old"]),
-                old_line: z.number().nullable(),
-                new_line: z.number().nullable(),
-            }),
-        }).nullable().optional(), // For multi-line diff notes
-        width: z.number().optional(), // For image diff notes
-        height: z.number().optional(), // For image diff notes
-        x: z.number().optional(), // For image diff notes
-        y: z.number().optional(), // For image diff notes
-    }).optional(),
-});
-export const GitLabDiscussionSchema = z.object({
-    id: z.string(),
-    individual_note: z.boolean(),
-    notes: z.array(GitLabDiscussionNoteSchema),
-});
-// Input schema for listing merge request discussions
-export const ListMergeRequestDiscussionsSchema = ProjectParamsSchema.extend({
-    merge_request_iid: z.number().describe("The IID of a merge request"),
-});
-// Input schema for updating a merge request discussion note
-export const UpdateMergeRequestNoteSchema = ProjectParamsSchema.extend({
-    merge_request_iid: z.number().describe("The IID of a merge request"),
-    discussion_id: z.string().describe("The ID of a thread"),
-    note_id: z.number().describe("The ID of a thread note"),
-    body: z.string().describe("The content of the note or reply"),
-    resolved: z.boolean().optional().describe("Resolve or unresolve the note"), // Optional based on API docs
-});
-// API Operation Parameter Schemas
-export const CreateOrUpdateFileSchema = ProjectParamsSchema.extend({
-    file_path: z.string().describe("Path where to create/update the file"),
-    content: z.string().describe("Content of the file"),
-    commit_message: z.string().describe("Commit message"),
-    branch: z.string().describe("Branch to create/update the file in"),
-    previous_path: z
-        .string()
-        .optional()
-        .describe("Path of the file to move/rename"),
-    last_commit_id: z
-        .string()
-        .optional()
-        .describe("Last known file commit ID"),
-    commit_id: z
-        .string()
-        .optional()
-        .describe("Current file commit ID (for update operations)"),
-});
-export const SearchRepositoriesSchema = z.object({
-    search: z.string().describe("Search query"), // Changed from query to match GitLab API
-    page: z
-        .number()
-        .optional()
-        .describe("Page number for pagination (default: 1)"),
-    per_page: z
-        .number()
-        .optional()
-        .describe("Number of results per page (default: 20)"),
-});
-export const CreateRepositorySchema = z.object({
-    name: z.string().describe("Repository name"),
-    description: z.string().optional().describe("Repository description"),
-    visibility: z
-        .enum(["private", "internal", "public"])
-        .optional()
-        .describe("Repository visibility level"),
-    initialize_with_readme: z
-        .boolean()
-        .optional()
-        .describe("Initialize with README.md"),
-});
-export const GetFileContentsSchema = ProjectParamsSchema.extend({
-    file_path: z.string().describe("Path to the file or directory"),
-    ref: z.string().optional().describe("Branch/tag/commit to get contents from"),
-});
-export const PushFilesSchema = ProjectParamsSchema.extend({
-    branch: z.string().describe("Branch to push to"),
-    files: z
-        .array(z.object({
-        file_path: z.string().describe("Path where to create the file"),
-        content: z.string().describe("Content of the file"),
-    }))
-        .describe("Array of files to push"),
-    commit_message: z.string().describe("Commit message"),
-});
-export const CreateIssueSchema = ProjectParamsSchema.extend({
-    title: z.string().describe("Issue title"),
-    description: z.string().optional().describe("Issue description"),
-    assignee_ids: z
-        .array(z.number())
-        .optional()
-        .describe("Array of user IDs to assign"),
-    labels: z.array(z.string()).optional().describe("Array of label names"),
-    milestone_id: z.number().optional().describe("Milestone ID to assign"),
-});
-export const CreateMergeRequestSchema = ProjectParamsSchema.extend({
-    title: z.string().describe("Merge request title"),
-    description: z.string().optional().describe("Merge request description"),
-    source_branch: z.string().describe("Branch containing changes"),
-    target_branch: z.string().describe("Branch to merge into"),
-    draft: z.boolean().optional().describe("Create as draft merge request"),
-    allow_collaboration: z
-        .boolean()
-        .optional()
-        .describe("Allow commits from upstream members"),
-});
-export const ForkRepositorySchema = ProjectParamsSchema.extend({
-    namespace: z.string().optional().describe("Namespace to fork to (full path)"),
-});
-export const CreateBranchSchema = ProjectParamsSchema.extend({
-    branch: z.string().describe("Name for the new branch"),
-    ref: z.string().optional().describe("Source branch/commit for new branch"),
-});
-export const GitLabMergeRequestDiffSchema = z.object({
-    old_path: z.string(),
-    new_path: z.string(),
-    a_mode: z.string(),
-    b_mode: z.string(),
-    diff: z.string(),
-    new_file: z.boolean(),
-    renamed_file: z.boolean(),
-    deleted_file: z.boolean(),
-});
-export const GetMergeRequestSchema = ProjectParamsSchema.extend({
-    merge_request_iid: z
-        .number()
-        .describe("The internal ID of the merge request"),
-});
-export const UpdateMergeRequestSchema = GetMergeRequestSchema.extend({
-    title: z.string().optional().describe("The title of the merge request"),
-    description: z
-        .string()
-        .optional()
-        .describe("The description of the merge request"),
-    target_branch: z.string().optional().describe("The target branch"),
-    assignee_ids: z
-        .array(z.number())
-        .optional()
-        .describe("The ID of the users to assign the MR to"),
-    labels: z.array(z.string()).optional().describe("Labels for the MR"),
-    state_event: z
-        .enum(["close", "reopen"])
-        .optional()
-        .describe("New state (close/reopen) for the MR"),
-    remove_source_branch: z
-        .boolean()
-        .optional()
-        .describe("Flag indicating if the source branch should be removed"),
-    squash: z
-        .boolean()
-        .optional()
-        .describe("Squash commits into a single commit when merging"),
-    draft: z.boolean().optional().describe("Work in progress merge request"),
-});
-export const GetMergeRequestDiffsSchema = GetMergeRequestSchema.extend({
-    view: z.enum(["inline", "parallel"]).optional().describe("Diff view type"),
-});
-export const CreateNoteSchema = z.object({
-    project_id: z.string().describe("Project ID or namespace/project_path"),
-    noteable_type: z
-        .enum(["issue", "merge_request"])
-        .describe("Type of noteable (issue or merge_request)"),
-    noteable_iid: z.number().describe("IID of the issue or merge request"),
-    body: z.string().describe("Note content"),
-});
-// Issues API operation schemas
-export const ListIssuesSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    assignee_id: z.number().optional().describe("Return issues assigned to the given user ID"),
-    assignee_username: z.string().optional().describe("Return issues assigned to the given username"),
-    author_id: z.number().optional().describe("Return issues created by the given user ID"),
-    author_username: z.string().optional().describe("Return issues created by the given username"),
-    confidential: z.boolean().optional().describe("Filter confidential or public issues"),
-    created_after: z.string().optional().describe("Return issues created after the given time"),
-    created_before: z.string().optional().describe("Return issues created before the given time"),
-    due_date: z.string().optional().describe("Return issues that have the due date"),
-    label_name: z.array(z.string()).optional().describe("Array of label names"),
-    milestone: z.string().optional().describe("Milestone title"),
-    scope: z.enum(['created-by-me', 'assigned-to-me', 'all']).optional().describe("Return issues from a specific scope"),
-    search: z.string().optional().describe("Search for specific terms"),
-    state: z.enum(['opened', 'closed', 'all']).optional().describe("Return issues with a specific state"),
-    updated_after: z.string().optional().describe("Return issues updated after the given time"),
-    updated_before: z.string().optional().describe("Return issues updated before the given time"),
-    with_labels_details: z.boolean().optional().describe("Return more details for each label"),
-    page: z.number().optional().describe("Page number for pagination"),
-    per_page: z.number().optional().describe("Number of items per page"),
-});
-export const GetIssueSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    issue_iid: z.number().describe("The internal ID of the project issue"),
-});
-export const UpdateIssueSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    issue_iid: z.number().describe("The internal ID of the project issue"),
-    title: z.string().optional().describe("The title of the issue"),
-    description: z.string().optional().describe("The description of the issue"),
-    assignee_ids: z.array(z.number()).optional().describe("Array of user IDs to assign issue to"),
-    confidential: z.boolean().optional().describe("Set the issue to be confidential"),
-    discussion_locked: z.boolean().optional().describe("Flag to lock discussions"),
-    due_date: z.string().optional().describe("Date the issue is due (YYYY-MM-DD)"),
-    labels: z.array(z.string()).optional().describe("Array of label names"),
-    milestone_id: z.number().optional().describe("Milestone ID to assign"),
-    state_event: z.enum(['close', 'reopen']).optional().describe("Update issue state (close/reopen)"),
-    weight: z.number().optional().describe("Weight of the issue (0-9)"),
-});
-export const DeleteIssueSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    issue_iid: z.number().describe("The internal ID of the project issue"),
-});
-// Issue links related schemas
-export const GitLabIssueLinkSchema = z.object({
-    source_issue: GitLabIssueSchema,
-    target_issue: GitLabIssueSchema,
-    link_type: z.enum(['relates_to', 'blocks', 'is_blocked_by']),
-});
-export const ListIssueLinksSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    issue_iid: z.number().describe("The internal ID of a project's issue"),
-});
-export const GetIssueLinkSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    issue_iid: z.number().describe("The internal ID of a project's issue"),
-    issue_link_id: z.number().describe("ID of an issue relationship"),
-});
-export const CreateIssueLinkSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    issue_iid: z.number().describe("The internal ID of a project's issue"),
-    target_project_id: z.string().describe("The ID or URL-encoded path of a target project"),
-    target_issue_iid: z.number().describe("The internal ID of a target project's issue"),
-    link_type: z.enum(['relates_to', 'blocks', 'is_blocked_by']).optional().describe("The type of the relation, defaults to relates_to"),
-});
-export const DeleteIssueLinkSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    issue_iid: z.number().describe("The internal ID of a project's issue"),
-    issue_link_id: z.number().describe("The ID of an issue relationship"),
-});
-// Namespace API operation schemas
-export const ListNamespacesSchema = z.object({
-    search: z.string().optional().describe("Search term for namespaces"),
-    page: z.number().optional().describe("Page number for pagination"),
-    per_page: z.number().optional().describe("Number of items per page"),
-    owned: z.boolean().optional().describe("Filter for namespaces owned by current user"),
-});
-export const GetNamespaceSchema = z.object({
-    namespace_id: z.string().describe("Namespace ID or full path"),
-});
-export const VerifyNamespaceSchema = z.object({
-    path: z.string().describe("Namespace path to verify"),
-});
-// Project API operation schemas
-export const GetProjectSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-});
-export const ListProjectsSchema = z.object({
-    search: z.string().optional().describe("Search term for projects"),
-    page: z.number().optional().describe("Page number for pagination"),
-    per_page: z.number().optional().describe("Number of items per page"),
-    owned: z.boolean().optional().describe("Filter for projects owned by current user"),
-    membership: z.boolean().optional().describe("Filter for projects where current user is a member"),
-    simple: z.boolean().optional().describe("Return only limited fields"),
-    archived: z.boolean().optional().describe("Filter for archived projects"),
-    visibility: z.enum(["public", "internal", "private"]).optional().describe("Filter by project visibility"),
-    order_by: z.enum(["id", "name", "path", "created_at", "updated_at", "last_activity_at"]).optional().describe("Return projects ordered by field"),
-    sort: z.enum(["asc", "desc"]).optional().describe("Return projects sorted in ascending or descending order"),
-    with_issues_enabled: z.boolean().optional().describe("Filter projects with issues feature enabled"),
-    with_merge_requests_enabled: z.boolean().optional().describe("Filter projects with merge requests feature enabled"),
-    min_access_level: z.number().optional().describe("Filter by minimum access level"),
-});
-// Label operation schemas
-export const ListLabelsSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    with_counts: z.boolean().optional().describe("Whether or not to include issue and merge request counts"),
-    include_ancestor_groups: z.boolean().optional().describe("Include ancestor groups"),
-    search: z.string().optional().describe("Keyword to filter labels by"),
-});
-export const GetLabelSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    label_id: z.union([z.number(), z.string()]).describe("The ID or title of a project's label"),
-    include_ancestor_groups: z.boolean().optional().describe("Include ancestor groups"),
-});
-export const CreateLabelSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    name: z.string().describe("The name of the label"),
-    color: z.string().describe("The color of the label given in 6-digit hex notation with leading '#' sign"),
-    description: z.string().optional().describe("The description of the label"),
-    priority: z.number().nullable().optional().describe("The priority of the label"),
-});
-export const UpdateLabelSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    label_id: z.union([z.number(), z.string()]).describe("The ID or title of a project's label"),
-    new_name: z.string().optional().describe("The new name of the label"),
-    color: z.string().optional().describe("The color of the label given in 6-digit hex notation with leading '#' sign"),
-    description: z.string().optional().describe("The new description of the label"),
-    priority: z.number().nullable().optional().describe("The new priority of the label"),
-});
-export const DeleteLabelSchema = z.object({
-    project_id: z.string().describe("Project ID or URL-encoded path"),
-    label_id: z.union([z.number(), z.string()]).describe("The ID or title of a project's label"),
-});
-// Group projects schema
-export const ListGroupProjectsSchema = z.object({
-    group_id: z.string().describe("Group ID or path"),
-    include_subgroups: z.boolean().optional().describe("Include projects from subgroups"),
-    search: z.string().optional().describe("Search term to filter projects"),
-    order_by: z.enum(['name', 'path', 'created_at', 'updated_at', 'last_activity_at']).optional().describe("Field to sort by"),
-    sort: z.enum(['asc', 'desc']).optional().describe("Sort direction"),
-    page: z.number().optional().describe("Page number"),
-    per_page: z.number().optional().describe("Number of results per page"),
-    archived: z.boolean().optional().describe("Filter for archived projects"),
-    visibility: z.enum(["public", "internal", "private"]).optional().describe("Filter by project visibility"),
-    with_issues_enabled: z.boolean().optional().describe("Filter projects with issues feature enabled"),
-    with_merge_requests_enabled: z.boolean().optional().describe("Filter projects with merge requests feature enabled"),
-    min_access_level: z.number().optional().describe("Filter by minimum access level"),
-    with_programming_language: z.string().optional().describe("Filter by programming language"),
-    starred: z.boolean().optional().describe("Filter by starred projects"),
-    statistics: z.boolean().optional().describe("Include project statistics"),
-    with_custom_attributes: z.boolean().optional().describe("Include custom attributes"),
-    with_security_reports: z.boolean().optional().describe("Include security reports")
-});

build/test-note.js

@@ -1,54 +0,0 @@
-/**
- * This test file verifies that the createNote function works correctly
- * with the fixed endpoint URL construction that uses plural resource names
- * (issues instead of issue, merge_requests instead of merge_request).
- */
-import fetch from "node-fetch";
-// GitLab API configuration (replace with actual values when testing)
-const GITLAB_API_URL = process.env.GITLAB_API_URL || "https://gitlab.com";
-const GITLAB_PERSONAL_ACCESS_TOKEN = process.env.GITLAB_TOKEN || "";
-const PROJECT_ID = process.env.PROJECT_ID || "your/project";
-const ISSUE_IID = Number(process.env.ISSUE_IID || "1");
-async function testCreateIssueNote() {
-    try {
-        // Using plural form "issues" in the URL
-        const url = new URL(`${GITLAB_API_URL}/api/v4/projects/${encodeURIComponent(PROJECT_ID)}/issues/${ISSUE_IID}/notes`);
-        const response = await fetch(url.toString(), {
-            method: "POST",
-            headers: {
-                Accept: "application/json",
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`,
-            },
-            body: JSON.stringify({ body: "Test note from API - with plural endpoint" }),
-        });
-        if (!response.ok) {
-            const errorBody = await response.text();
-            throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
-        }
-        const data = await response.json();
-        console.log("Successfully created note:");
-        console.log(JSON.stringify(data, null, 2));
-        return true;
-    }
-    catch (error) {
-        console.error("Error creating note:", error);
-        return false;
-    }
-}
-// Only run the test if executed directly
-if (require.main === module) {
-    console.log("Testing note creation with plural 'issues' endpoint...");
-    testCreateIssueNote().then(success => {
-        if (success) {
-            console.log("✅ Test successful!");
-            process.exit(0);
-        }
-        else {
-            console.log("❌ Test failed!");
-            process.exit(1);
-        }
-    });
-}
-// Export for use in other tests
-export { testCreateIssueNote };

docs/setup-github-secrets.md

@@ -0,0 +1,57 @@
+# GitHub Secrets Setup Guide
+
+## 1. Navigate to GitHub Repository
+
+1. Go to your `gitlab-mcp` repository on GitHub
+2. Click on the Settings tab
+3. In the left sidebar, select "Secrets and variables" → "Actions"
+
+## 2. Add Secrets
+
+Click the "New repository secret" button and add the following secrets:
+
+### GITLAB_TOKEN_TEST
+
+- **Name**: `GITLAB_TOKEN_TEST`
+- **Value**: Your GitLab Personal Access Token
+- Used for integration tests to call the real GitLab API
+
+### TEST_PROJECT_ID
+
+- **Name**: `TEST_PROJECT_ID`
+- **Value**: Your test project ID (e.g., `70322092`)
+- The GitLab project ID used for testing
+
+### GITLAB_API_URL (Optional)
+
+- **Name**: `GITLAB_API_URL`
+- **Value**: `https://gitlab.com`
+- Only set this if using a different GitLab instance (default is https://gitlab.com)
+
+## 3. Verify Configuration
+
+To verify your secrets are properly configured:
+
+1. Create a PR or update an existing PR
+2. Check the workflow execution in the Actions tab
+3. Confirm that the "integration-test" job successfully calls the GitLab API
+
+## Security Best Practices
+
+- Never commit GitLab tokens directly in code
+- Grant minimal required permissions to tokens (read_api, write_repository)
+- Rotate tokens regularly
+
+## Local Testing
+
+To run integration tests locally:
+
+```bash
+export GITLAB_TOKEN_TEST="your-token-here"
+export TEST_PROJECT_ID="70322092"
+export GITLAB_API_URL="https://gitlab.com"
+
+npm run test:integration
+```
+
+⚠️ **Important**: When testing locally, use environment variables and never commit tokens to the repository!

event.json

@@ -0,0 +1,6 @@
+{
+    "action": "published",
+    "release": {
+        "tag_name": "v1.0.52"
+    }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "1.0.22",
+  "version": "1.0.52",
   "description": "MCP server for using the GitLab API",
   "license": "MIT",
   "author": "zereight",
@@ -19,17 +19,33 @@
     "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
     "prepare": "npm run build",
     "watch": "tsc --watch",
-    "deploy": "npm run build && npm publish"
+    "deploy": "npm publish --access public",
+    "generate-tools": "npx ts-node scripts/generate-tools-readme.ts",
+    "test": "node test/validate-api.js",
+    "test:integration": "node test/validate-api.js",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "format": "prettier --write \"**/*.{js,ts,json,md}\"",
+    "format:check": "prettier --check \"**/*.{js,ts,json,md}\""
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.8.0",
+    "form-data": "^4.0.0",
     "@types/node-fetch": "^2.6.12",
+    "http-proxy-agent": "^7.0.2",
+    "https-proxy-agent": "^7.0.6",
     "node-fetch": "^3.3.2",
+    "socks-proxy-agent": "^8.0.5",
     "zod-to-json-schema": "^3.23.5"
   },
   "devDependencies": {
     "@types/node": "^22.13.10",
     "typescript": "^5.8.2",
-    "zod": "^3.24.2"
+    "zod": "^3.24.2",
+    "@typescript-eslint/eslint-plugin": "^8.21.0",
+    "@typescript-eslint/parser": "^8.21.0",
+    "eslint": "^9.18.0",
+    "prettier": "^3.4.2",
+    "ts-node": "^10.9.2"
   }
-}
+}

release-notes.md

@@ -0,0 +1,5 @@
+### 1.0.40 (2025-05-21)
+
+- Added support for listing discussions (comments/notes) on GitLab issues.
+  - Example: You can now easily fetch all conversations (comments) attached to an issue via the API.
+  - Related PR: [#44](https://github.com/zereight/gitlab-mcp/pull/44)

scripts/generate-tools-readme.ts

@@ -0,0 +1,53 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function main() {
+  const repoRoot = path.resolve(__dirname, "..");
+  const indexPath = path.join(repoRoot, "index.ts");
+  const readmePath = path.join(repoRoot, "README.md");
+
+  // 1. Read index.ts
+  const code = fs.readFileSync(indexPath, "utf-8");
+
+  // 2. Extract allTools array block
+  const match = code.match(/const allTools = \[([\s\S]*?)\];/);
+  if (!match) {
+    console.error("Unable to locate allTools array in index.ts");
+    process.exit(1);
+  }
+  const toolsBlock = match[1];
+
+  // 3. Parse tool entries
+  const toolRegex = /name:\s*"([^"]+)",[\s\S]*?description:\s*"([^"]+)"/g;
+  const tools: { name: string; description: string }[] = [];
+  let m: RegExpExecArray | null;
+  while ((m = toolRegex.exec(toolsBlock)) !== null) {
+    tools.push({ name: m[1], description: m[2] });
+  }
+
+  // 4. Generate markdown
+  const lines = tools.map((tool, index) => {
+    return `${index + 1}. \`${tool.name}\` - ${tool.description}`;
+  });
+  const markdown = lines.join("\n");
+
+  // 5. Read README.md and replace between markers
+  const readme = fs.readFileSync(readmePath, "utf-8");
+  const updated = readme.replace(
+    /<!-- TOOLS-START -->([\s\S]*?)<!-- TOOLS-END -->/,
+    `<!-- TOOLS-START -->\n${markdown}\n<!-- TOOLS-END -->`
+  );
+
+  // 6. Write back
+  fs.writeFileSync(readmePath, updated, "utf-8");
+  console.log("README.md tools section updated.");
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

scripts/image_push.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+if [ -z "$1" ]; then
+  echo "Error: docker user name required."
+  exit 1
+fi
+
+DOCKER_USER=$1
+IMAGE_NAME=gitlab-mcp
+IMAGE_VERSION=$(jq -r '.version' package.json)
+
+echo "${DOCKER_USER}/${IMAGE_NAME}:${IMAGE_VERSION}"
+docker build --platform=linux/arm64 -t "${DOCKER_USER}/${IMAGE_NAME}:latest" .
+
+docker tag "${DOCKER_USER}/${IMAGE_NAME}:latest" "${DOCKER_USER}/${IMAGE_NAME}:${IMAGE_VERSION}"
+
+docker push "${DOCKER_USER}/${IMAGE_NAME}:latest"
+docker push "${DOCKER_USER}/${IMAGE_NAME}:${IMAGE_VERSION}"

scripts/validate-pr.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+# PR Validation Script
+# This script runs all necessary checks before merging a PR
+
+set -e
+
+echo "🔍 Starting PR validation..."
+
+# Check if Node.js is installed
+if ! command -v node &> /dev/null; then
+    echo "❌ Node.js is not installed"
+    exit 1
+fi
+
+echo "📦 Installing dependencies..."
+npm ci
+
+echo "🔨 Building project..."
+npm run build
+
+echo "🧪 Running unit tests..."
+npm run test:unit
+
+echo "✨ Checking code formatting..."
+npm run format:check || {
+    echo "⚠️  Code formatting issues found. Run 'npm run format' to fix."
+    exit 1
+}
+
+echo "🔍 Running linter..."
+npm run lint || {
+    echo "⚠️  Linting issues found. Run 'npm run lint:fix' to fix."
+    exit 1
+}
+
+echo "📊 Running tests with coverage..."
+npm run test:coverage
+
+# Check if integration tests should run
+if [ -n "$GITLAB_TOKEN" ] && [ -n "$TEST_PROJECT_ID" ]; then
+    echo "🌐 Running integration tests..."
+    npm run test:integration
+else
+    echo "⚠️  Skipping integration tests (no credentials provided)"
+fi
+
+echo "🐳 Testing Docker build..."
+if command -v docker &> /dev/null; then
+    docker build -t mcp-gitlab-test .
+    echo "✅ Docker build successful"
+else
+    echo "⚠️  Docker not available, skipping Docker build test"
+fi
+
+echo "✅ All PR validation checks passed!"

test-note.ts

@@ -33,9 +33,7 @@ async function testCreateIssueNote() {
 
     if (!response.ok) {
       const errorBody = await response.text();
-      throw new Error(
-        `GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`
-      );
+      throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
     }
 
     const data = await response.json();

test/validate-api.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+// Simple API validation script for PR testing
+import fetch from "node-fetch";
+
+const GITLAB_API_URL = process.env.GITLAB_API_URL || "https://gitlab.com";
+const GITLAB_TOKEN = process.env.GITLAB_TOKEN_TEST || process.env.GITLAB_TOKEN;
+const TEST_PROJECT_ID = process.env.TEST_PROJECT_ID;
+
+async function validateGitLabAPI() {
+  console.log("🔍 Validating GitLab API connection...\n");
+
+  if (!GITLAB_TOKEN) {
+    console.warn("⚠️  No GitLab token provided. Skipping API validation.");
+    console.log("Set GITLAB_TOKEN_TEST or GITLAB_TOKEN to enable API validation.\n");
+    return true;
+  }
+
+  if (!TEST_PROJECT_ID) {
+    console.warn("⚠️  No test project ID provided. Skipping API validation.");
+    console.log("Set TEST_PROJECT_ID to enable API validation.\n");
+    return true;
+  }
+
+  const tests = [
+    {
+      name: "Fetch project info",
+      url: `${GITLAB_API_URL}/api/v4/projects/${encodeURIComponent(TEST_PROJECT_ID)}`,
+      validate: data => data.id && data.name,
+    },
+    {
+      name: "List issues",
+      url: `${GITLAB_API_URL}/api/v4/projects/${encodeURIComponent(TEST_PROJECT_ID)}/issues?per_page=1`,
+      validate: data => Array.isArray(data),
+    },
+    {
+      name: "List merge requests",
+      url: `${GITLAB_API_URL}/api/v4/projects/${encodeURIComponent(TEST_PROJECT_ID)}/merge_requests?per_page=1`,
+      validate: data => Array.isArray(data),
+    },
+    {
+      name: "List branches",
+      url: `${GITLAB_API_URL}/api/v4/projects/${encodeURIComponent(TEST_PROJECT_ID)}/repository/branches?per_page=1`,
+      validate: data => Array.isArray(data),
+    },
+    {
+      name: "List pipelines",
+      url: `${GITLAB_API_URL}/api/v4/projects/${encodeURIComponent(TEST_PROJECT_ID)}/pipelines?per_page=5`,
+      validate: data => Array.isArray(data),
+    },
+  ];
+
+  let allPassed = true;
+  let firstPipelineId = null;
+
+  for (const test of tests) {
+    try {
+      console.log(`Testing: ${test.name}`);
+      const response = await fetch(test.url, {
+        headers: {
+          Authorization: `Bearer ${GITLAB_TOKEN}`,
+          Accept: "application/json",
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      const data = await response.json();
+
+      if (test.validate(data)) {
+        console.log(`✅ ${test.name} - PASSED\n`);
+        
+        // If we found pipelines, save the first one for additional testing
+        if (test.name === "List pipelines" && data.length > 0) {
+          firstPipelineId = data[0].id;
+        }
+      } else {
+        console.log(`❌ ${test.name} - FAILED (invalid response format)\n`);
+        allPassed = false;
+      }
+    } catch (error) {
+      console.log(`❌ ${test.name} - FAILED`);
+      console.log(`   Error: ${error.message}\n`);
+      allPassed = false;
+    }
+  }
+
+  // Test pipeline-specific endpoints if we have a pipeline ID
+  if (firstPipelineId) {
+    console.log(`Found pipeline #${firstPipelineId}, testing pipeline-specific endpoints...\n`);
+    
+    const pipelineTests = [
+      {
+        name: `Get pipeline #${firstPipelineId} details`,
+        url: `${GITLAB_API_URL}/api/v4/projects/${encodeURIComponent(TEST_PROJECT_ID)}/pipelines/${firstPipelineId}`,
+        validate: data => data.id === firstPipelineId && data.status,
+      },
+      {
+        name: `List pipeline #${firstPipelineId} jobs`,
+        url: `${GITLAB_API_URL}/api/v4/projects/${encodeURIComponent(TEST_PROJECT_ID)}/pipelines/${firstPipelineId}/jobs`,
+        validate: data => Array.isArray(data),
+      },
+    ];
+
+    for (const test of pipelineTests) {
+      try {
+        console.log(`Testing: ${test.name}`);
+        const response = await fetch(test.url, {
+          headers: {
+            Authorization: `Bearer ${GITLAB_TOKEN}`,
+            Accept: "application/json",
+          },
+        });
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const data = await response.json();
+
+        if (test.validate(data)) {
+          console.log(`✅ ${test.name} - PASSED\n`);
+        } else {
+          console.log(`❌ ${test.name} - FAILED (invalid response format)\n`);
+          allPassed = false;
+        }
+      } catch (error) {
+        console.log(`❌ ${test.name} - FAILED`);
+        console.log(`   Error: ${error.message}\n`);
+        allPassed = false;
+      }
+    }
+  }
+
+  if (allPassed) {
+    console.log("✅ All API validation tests passed!");
+  } else {
+    console.log("❌ Some API validation tests failed!");
+  }
+
+  return allPassed;
+}
+
+// Run validation
+validateGitLabAPI()
+  .then(success => process.exit(success ? 0 : 1))
+  .catch(error => {
+    console.error("Unexpected error:", error);
+    process.exit(1);
+  });
+
+export { validateGitLabAPI };