format

# Add Gitea Actions support (secrets, variables, workflows, runs, jobs, logs)

## Summary

This PR adds comprehensive support for Gitea Actions API to the MCP server, enabling users to manage Actions secrets, variables, workflows, runs, jobs, and logs through the Model Context Protocol interface.

## New Features

### Actions Secrets (Repository & Organization Level)
- `list_repo_action_secrets` - List repository secrets (metadata only, values never exposed)
- `upsert_repo_action_secret` - Create or update a repository secret
- `delete_repo_action_secret` - Delete a repository secret
- `list_org_action_secrets` - List organization secrets
- `upsert_org_action_secret` - Create or update an organization secret
- `delete_org_action_secret` - Delete an organization secret

### Actions Variables (Repository & Organization Level)
- `list_repo_action_variables` - List repository variables
- `get_repo_action_variable` - Get a specific repository variable
- `create_repo_action_variable` - Create a repository variable
- `update_repo_action_variable` - Update a repository variable
- `delete_repo_action_variable` - Delete a repository variable
- `list_org_action_variables` - List organization variables
- `get_org_action_variable` - Get a specific organization variable
- `create_org_action_variable` - Create an organization variable
- `update_org_action_variable` - Update an organization variable
- `delete_org_action_variable` - Delete an organization variable

### Actions Workflows
- `list_repo_action_workflows` - List repository workflows
- `get_repo_action_workflow` - Get a specific workflow by ID
- `dispatch_repo_action_workflow` - Trigger (dispatch) a workflow run with optional inputs

### Actions Runs
- `list_repo_action_runs` - List workflow runs with optional status filtering
- `get_repo_action_run` - Get a specific run by ID
- `cancel_repo_action_run` - Cancel a running workflow
- `rerun_repo_action_run` - Rerun a workflow (with fallback routes for version compatibility)

### Actions Jobs
- `list_repo_action_jobs` - List all jobs in a repository
- `list_repo_action_run_jobs` - List jobs for a specific workflow run

### Actions Job Logs
- `get_repo_action_job_log_preview` - Get log preview with tail/limit support (chat-friendly)
- `download_repo_action_job_log` - Download full job logs to file (default: `~/.gitea-mcp/artifacts/actions-logs/`)

## Implementation Details

### Architecture
- Follows existing codebase patterns: new `operation/actions/` package with tools registered via `Tool.RegisterRead/Write()`
- Uses Gitea SDK (`code.gitea.io/sdk/gitea v0.22.1`) where endpoints are available
- Shared REST helper (`pkg/gitea/rest.go`) for endpoints not yet in SDK (workflows, runs, jobs, logs)

### Security
- **Secrets never expose values**: List/get operations return only safe metadata (name, description, created_at)
- Request-scoped token support: HTTP Bearer tokens properly respected (fixes issue where wiki REST calls were hardcoding `flag.Token`)

### Compatibility
- Fallback route logic for dispatch/rerun endpoints (handles Gitea version differences)
- Clear error messages when endpoints aren't available, referencing Gitea 1.24 API docs
- Graceful handling of 404/405 responses for unsupported endpoints

### Testing
- Unit tests for REST helper token precedence
- Unit tests for log truncation/formatting helpers
- All existing tests pass

## Files Changed

- **New**: `operation/actions/*` - Complete Actions module (secrets, variables, runs, logs)
- **New**: `pkg/gitea/rest.go` - Shared REST helper with token context support
- **New**: `pkg/gitea/rest_test.go` - Tests for REST helper
- **Modified**: `operation/operation.go` - Register Actions tools
- **Modified**: `operation/wiki/wiki.go` - Refactored to use shared REST helper (removed hardcoded token)
- **Modified**: `README.md` - Added all new tools to documentation

## Testing

```bash
# All tests pass
go test ./...

# Build succeeds
make build
```

## Example Usage

```python
# List repository secrets
mcp.call_tool("list_repo_action_secrets", {"owner": "user", "repo": "myrepo"})

# Trigger a workflow
mcp.call_tool("dispatch_repo_action_workflow", {
    "owner": "user",
    "repo": "myrepo",
    "workflow_id": 123,
    "ref": "main",
    "inputs": {"deploy_env": "production"}
})

# Get job log preview (last 100 lines)
mcp.call_tool("get_repo_action_job_log_preview", {
    "owner": "user",
    "repo": "myrepo",
    "job_id": 456,
    "tail_lines": 100
})
```

## Breaking Changes

None - this is a purely additive change.

## Related Issues

Fixes #[issue-number] (if applicable)

## Checklist

- [x] Code follows existing patterns and conventions
- [x] All tests pass
- [x] Documentation updated (README.md)
- [x] No breaking changes
- [x] Security considerations addressed (secrets never expose values)
- [x] Error handling implemented with clear messages
- [x] Version compatibility considered (fallback routes)

Reviewed-on: https://gitea.com/gitea/gitea-mcp/pulls/110
Reviewed-by: hiifong <f@f.style>
Co-authored-by: Shawn Anderson <sanderson@eye-catcher.com>
Co-committed-by: Shawn Anderson <sanderson@eye-catcher.com>

.gitea/workflows/release-tag.yml

@@ -66,6 +66,8 @@ jobs:
             linux/amd64
             linux/arm64
           push: true
+          build-args: |
+            VERSION=${{ steps.meta.outputs.REPO_VERSION }}
           tags: |
             ${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}-server:${{ steps.meta.outputs.REPO_VERSION }}
             ${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}-server:${{ env.DOCKER_LATEST }}

BUILDING.md

@@ -0,0 +1,63 @@
+# Building gitea-mcp on Windows
+
+This project includes PowerShell and batch scripts to build the gitea-mcp application on Windows systems.
+
+## Prerequisites
+
+- Go 1.24 or later
+- Git (for version information)
+- PowerShell 5.1 or later (included with Windows 10/11)
+
+## Build Scripts
+
+### PowerShell Script (`build.ps1`)
+
+The main build script that replicates all Makefile functionality:
+
+```powershell
+# Show help
+.\build.ps1 help
+
+# Build the application
+.\build.ps1 build
+
+# Install the application
+.\build.ps1 install
+
+# Clean build artifacts
+.\build.ps1 clean
+
+# Run in development mode (hot reload)
+.\build.ps1 dev
+
+# Update vendor dependencies
+.\build.ps1 vendor
+```
+
+### Batch File Wrapper (`build.bat`)
+
+A simple wrapper to run the PowerShell script:
+
+```cmd
+# Run with default help target
+build.bat
+
+# Run specific target
+build.bat build
+build.bat install
+```
+
+## Available Targets
+
+- **help** - Print help message
+- **build** - Build the application executable
+- **install** - Build and install to GOPATH/bin
+- **uninstall** - Remove executable from GOPATH/bin
+- **clean** - Remove build artifacts
+- **air** - Install air for hot reload development
+- **dev** - Run with hot reload development
+- **vendor** - Tidy and verify Go module dependencies
+
+## Output
+
+The build process creates `gitea-mcp.exe` in the project directory.

CLAUDE.md

@@ -0,0 +1,71 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Development Commands
+
+**Build**: `make build` - Build the gitea-mcp binary
+**Install**: `make install` - Build and install to GOPATH/bin
+**Clean**: `make clean` - Remove build artifacts
+**Test**: `go test ./...` - Run all tests
+**Hot reload**: `make dev` - Start development server with hot reload (requires air)
+**Dependencies**: `make vendor` - Tidy and verify module dependencies
+
+## Architecture Overview
+
+This is a **Gitea MCP (Model Context Protocol) Server** written in Go that provides MCP tools for interacting with Gitea repositories, issues, pull requests, users, and more.
+
+**Core Components**:
+
+- `main.go` + `cmd/cmd.go`: CLI entry point and flag parsing
+- `operation/operation.go`: Main server setup and tool registration
+- `pkg/tool/tool.go`: Tool registry with read/write categorization
+- `operation/*/`: Individual tool modules (user, repo, issue, pull, search, wiki, etc.)
+
+**Transport Modes**:
+
+- **stdio** (default): Standard input/output for MCP clients
+- **http**: HTTP server mode on configurable port (default 8080)
+
+**Authentication**:
+
+- Global token via `--token` flag or `GITEA_ACCESS_TOKEN` env var
+- HTTP mode supports per-request Bearer token override in Authorization header
+- Token precedence: HTTP Authorization header > CLI flag > environment variable
+
+**Tool Organization**:
+
+- Tools are categorized as read-only or write operations
+- `--read-only` flag exposes only read tools
+- Tool modules register via `Tool.RegisterRead()` and `Tool.RegisterWrite()`
+
+**Key Configuration**:
+
+- Default Gitea host: `https://gitea.com` (override with `--host` or `GITEA_HOST`)
+- Environment variables can override CLI flags: `MCP_MODE`, `GITEA_READONLY`, `GITEA_DEBUG`, `GITEA_INSECURE`
+- Logs are written to `~/.gitea-mcp/gitea-mcp.log` with rotation
+
+## Available Tools
+
+The server provides 40+ MCP tools covering:
+
+- **User**: get_my_user_info, get_user_orgs, search_users
+- **Repository**: create_repo, fork_repo, list_my_repos, search_repos
+- **Branches/Tags**: create_branch, delete_branch, list_branches, create_tag, list_tags
+- **Files**: get_file_content, create_file, update_file, delete_file, get_dir_content
+- **Issues**: create_issue, list_repo_issues, create_issue_comment, edit_issue
+- **Pull Requests**: create_pull_request, list_repo_pull_requests, get_pull_request_by_index
+- **Releases**: create_release, list_releases, get_latest_release
+- **Wiki**: create_wiki_page, update_wiki_page, list_wiki_pages
+- **Search**: search_repos, search_users, search_org_teams
+- **Version**: get_gitea_mcp_server_version
+
+## Common Development Patterns
+
+**Testing**: Use `go test ./operation -run TestFunctionName` for specific tests
+
+**Token Context**: HTTP requests use `pkg/context.TokenContextKey` for request-scoped token access
+
+**Flag Access**: All packages access configuration via global variables in `pkg/flag/flag.go`
+
+**Graceful Shutdown**: HTTP mode implements graceful shutdown with 10-second timeout on SIGTERM/SIGINT

README.md

@@ -133,25 +133,16 @@ To configure the MCP server for Gitea, add the following to your MCP configurati
 }
 ```
 
-- **sse mode**
-
-```json
-{
-  "mcpServers": {
-    "gitea": {
-      "url": "http://localhost:8080/sse"
-    }
-  }
-}
-```
-
 - **http mode**
 
 ```json
 {
   "mcpServers": {
     "gitea": {
-      "url": "http://localhost:8080/mcp"
+      "url": "http://localhost:8080/mcp",
+      "headers": {
+        "Authorization": "Bearer <your personal access token>"
+      }
     }
   }
 }
@@ -174,7 +165,7 @@ list all my repositories
 The Gitea MCP Server supports the following tools:
 
 |              Tool               |    Scope     |                       Description                        |
-| :--------------------------: | :----------: | :------------------------------------------------------: |
+| :-----------------------------: | :----------: | :------------------------------------------------------: |
 |        get_my_user_info         |     User     |      Get the information of the authenticated user       |
 |          get_user_orgs          |     User     | Get organizations associated with the authenticated user |
 |           create_repo           |  Repository  |                 Create a new repository                  |
@@ -208,17 +199,55 @@ The Gitea MCP Server supports the following tools:
 |    get_pull_request_by_index    | Pull Request |             Get a pull request by its index              |
 |     list_repo_pull_requests     | Pull Request |          List all pull requests in a repository          |
 |       create_pull_request       | Pull Request |                Create a new pull request                 |
+|  create_pull_request_reviewer   | Pull Request |             Add reviewers to a pull request              |
 |          search_users           |     User     |                     Search for users                     |
 |        search_org_teams         | Organization |           Search for teams in an organization            |
+|         list_org_labels         | Organization |        List labels defined at organization level         |
+|        create_org_label         | Organization |            Create a label in an organization             |
+|         edit_org_label          | Organization |             Edit a label in an organization              |
+|        delete_org_label         | Organization |            Delete a label in an organization             |
 |          search_repos           |  Repository  |                 Search for repositories                  |
+|    list_repo_action_secrets     |   Actions    |     List repository Actions secrets (metadata only)      |
+|    upsert_repo_action_secret    |   Actions    |    Create/update (upsert) a repository Actions secret    |
+|    delete_repo_action_secret    |   Actions    |            Delete a repository Actions secret            |
+|     list_org_action_secrets     |   Actions    |    List organization Actions secrets (metadata only)     |
+|    upsert_org_action_secret     |   Actions    |  Create/update (upsert) an organization Actions secret   |
+|    delete_org_action_secret     |   Actions    |          Delete an organization Actions secret           |
+|   list_repo_action_variables    |   Actions    |            List repository Actions variables             |
+|    get_repo_action_variable     |   Actions    |            Get a repository Actions variable             |
+|   create_repo_action_variable   |   Actions    |           Create a repository Actions variable           |
+|   update_repo_action_variable   |   Actions    |           Update a repository Actions variable           |
+|   delete_repo_action_variable   |   Actions    |           Delete a repository Actions variable           |
+|    list_org_action_variables    |   Actions    |           List organization Actions variables            |
+|     get_org_action_variable     |   Actions    |           Get an organization Actions variable           |
+|   create_org_action_variable    |   Actions    |         Create an organization Actions variable          |
+|   update_org_action_variable    |   Actions    |         Update an organization Actions variable          |
+|   delete_org_action_variable    |   Actions    |         Delete an organization Actions variable          |
+|   list_repo_action_workflows    |   Actions    |            List repository Actions workflows             |
+|    get_repo_action_workflow     |   Actions    |            Get a repository Actions workflow             |
+|  dispatch_repo_action_workflow  |   Actions    |     Trigger (dispatch) a repository Actions workflow     |
+|      list_repo_action_runs      |   Actions    |               List repository Actions runs               |
+|       get_repo_action_run       |   Actions    |               Get a repository Actions run               |
+|     cancel_repo_action_run      |   Actions    |             Cancel a repository Actions run              |
+|      rerun_repo_action_run      |   Actions    |              Rerun a repository Actions run              |
+|      list_repo_action_jobs      |   Actions    |               List repository Actions jobs               |
+|    list_repo_action_run_jobs    |   Actions    |               List Actions jobs for a run                |
+| get_repo_action_job_log_preview |   Actions    |           Get a job log preview (tail/limited)           |
+|  download_repo_action_job_log   |   Actions    |               Download a job log to a file               |
 |  get_gitea_mcp_server_version   |    Server    |         Get the version of the Gitea MCP Server          |
+|         list_wiki_pages         |     Wiki     |           List all wiki pages in a repository            |
+|          get_wiki_page          |     Wiki     |           Get a wiki page content and metadata           |
+|       get_wiki_revisions        |     Wiki     |           Get revisions history of a wiki page           |
+|        create_wiki_page         |     Wiki     |                  Create a new wiki page                  |
+|        update_wiki_page         |     Wiki     |               Update an existing wiki page               |
+|        delete_wiki_page         |     Wiki     |                    Delete a wiki page                    |
 
 ## 🐛 Debugging
 
-To enable debug mode, add the `-d` flag when running the Gitea MCP Server with sse mode:
+To enable debug mode, add the `-d` flag when running the Gitea MCP Server with http mode:
 
 ```sh
-./gitea-mcp -t sse [--port 8080] --token <your personal access token> -d
+./gitea-mcp -t http [--port 8080] --token <your personal access token> -d
 ```
 
 ## 🛠 Troubleshooting

README.zh-cn.md

@@ -14,9 +14,9 @@
   - [什么是 MCP？](#什么是-mcp)
   - [🚧 安装](#-安装)
     - [在 VS Code 中使用](#在-vs-code-中使用)
-    - [📥 下载官方 Gitea MCP 二进制版本](#-下载官方-gitea-mcp-二进制版本)
+    - [📥 下载官方二进制版本](#-下载官方二进制版本)
-    - [🔧 从源代码构建](#-从源代码构建)
+    - [🔧 从源码构建](#-从源码构建)
-    - [📁 添加到 PATH](#-添加到-path)
+    - [📁 加入 PATH](#-加入-path)
   - [🚀 使用](#-使用)
   - [✅ 可用工具](#-可用工具)
   - [🐛 调试](#-调试)
@@ -24,23 +24,23 @@
 
 ## 什么是 Gitea？
 
-Gitea 是一个由社区管理的轻量级代码托管解决方案，使用 Go 语言编写。它以 MIT 许可证发布。Gitea 提供 Git 托管，包括仓库查看器、问题追踪、拉取请求等功能。
+Gitea 是一个由社区管理的轻量级代码托管解决方案，使用 Go 语言编写，采用 MIT 许可证。Gitea 提供 Git 托管，包括仓库浏览、问题追踪、拉取请求等功能。
 
 ## 什么是 MCP？
 
-Model Context Protocol (MCP) 是一种协议，允许通过聊天界面整合各种工具和系统。它能够无缝执行命令和管理仓库、用户和其他资源。
+Model Context Protocol (MCP) 是一种协议，允许通过聊天界面整合各种工具和系统。它能够无缝执行命令并管理仓库、用户及其他资源。
 
 ## 🚧 安装
 
 ### 在 VS Code 中使用
 
-要快速安装，请使用本 README 顶部的单击安装按钮之一。
+要快速安装，请使用本 README 顶部的安装按钮。
 
-要手动安装，请将以下 JSON 块添加到 VS Code 的用户设置 (JSON) 文件中。您可以通过按 `Ctrl + Shift + P` 并输入 `Preferences: Open User Settings (JSON)` 来完成此操作。
+如需手动安装，请将以下 JSON 块添加到 VS Code 的用户设置 (JSON) 文件。可通过按 `Ctrl + Shift + P` 并输入 `Preferences: Open User Settings (JSON)`。
 
-或者，您可以将其添加到工作区中的 `.vscode/mcp.json` 文件中。这将允许您与他人共享配置。
+也可添加到工作区的 `.vscode/mcp.json` 文件，方便与他人共享配置。
 
-> 请注意，`.vscode/mcp.json` 文件中不需要 `mcp` 键。
+> `.vscode/mcp.json` 文件不需要 `mcp` 键。
 
 ```json
 {
@@ -73,22 +73,22 @@ Model Context Protocol (MCP) 是一种协议，允许通过聊天界面整合各
 }
 ```
 
-### 📥 下载官方 Gitea MCP 二进制版本
+### 📥 下载官方二进制版本
 
-您可以从[官方 Gitea MCP 二进制版本](https://gitea.com/gitea/gitea-mcp/releases)下载官方版本。
+可在 [官方 Gitea MCP 二进制版本](https://gitea.com/gitea/gitea-mcp/releases) 下载。
 
-### 🔧 从源代码构建
+### 🔧 从源码构建
 
-您可以使用 Git 克隆仓库来下载源代码：
+可用 Git 下载源码：
 
 ```bash
 git clone https://gitea.com/gitea/gitea-mcp.git
 ```
 
-在构建之前，请确保您已安装以下内容：
+构建前请先安装：
 
 - make
-- Golang (建议使用 Go 1.24 或更高版本)
+- Golang（建议 Go 1.24 及以上）
 
 然后运行：
 
@@ -96,9 +96,9 @@ git clone https://gitea.com/gitea/gitea-mcp.git
 make install
 ```
 
-### 📁 添加到 PATH
+### 📁 加入 PATH
 
-构建后，将二进制文件 gitea-mcp 复制到系统 PATH 中包含的目录。例如：
+安装后，将 gitea-mcp 可执行文件复制到系统 PATH 目录，例如：
 
 ```bash
 cp gitea-mcp /usr/local/bin/
@@ -106,8 +106,8 @@ cp gitea-mcp /usr/local/bin/
 
 ## 🚀 使用
 
-此示例适用于 Cursor，您也可以在 VSCode 中使用插件。
+此示例适用于 Cursor，也可在 VSCode 使用插件。  
-要配置 Gitea 的 MCP 服务器，请将以下内容添加到您的 MCP 配置文件中：
+要配置 Gitea MCP 服务器，请将以下内容添加到 MCP 配置文件：
 
 - **stdio 模式**
 
@@ -133,25 +133,16 @@ cp gitea-mcp /usr/local/bin/
 }
 ```
 
-- **sse 模式**
-
-```json
-{
-  "mcpServers": {
-    "gitea": {
-      "url": "http://localhost:8080/sse"
-    }
-  }
-}
-```
-
 - **http 模式**
 
 ```json
 {
   "mcpServers": {
     "gitea": {
-      "url": "http://localhost:8080/mcp"
+      "url": "http://localhost:8080/mcp",
+      "headers": {
+        "Authorization": "Bearer <your personal access token>"
+      }
     }
   }
 }
@@ -160,10 +151,10 @@ cp gitea-mcp /usr/local/bin/
 **默认日志路径**: `$HOME/.gitea-mcp/gitea-mcp.log`
 
 > [!注意]
-> 您可以通过命令行参数或环境变量提供您的 Gitea 主机和访问令牌。
+> 可通过命令行参数或环境变量提供 Gitea 主机和访问令牌。  
-> 命令行参数具有最高优先级
+> 命令行参数优先。
 
-一切设置完成后，请尝试在您的 MCP 兼容聊天框中输入以下内容：
+一切设置完成后，可在 MCP 聊天框输入：
 
 ```text
 列出我所有的仓库
@@ -174,60 +165,71 @@ cp gitea-mcp /usr/local/bin/
 Gitea MCP 服务器支持以下工具：
 
 |             工具             |   范围   |            描述            |
-| :--------------------------: | :------: | :--------------------------: |
+| :--------------------------: | :------: | :------------------------: |
-|       get_my_user_info       |   用户   |     获取已认证用户的信息     |
+|       get_my_user_info       |   用户   |     获取已认证用户信息     |
-|        get_user_orgs         |   用户   |   获取已认证用户关联的组织   |
+|        get_user_orgs         |   用户   |   获取已认证用户关联组织   |
-|         create_repo          |   仓库   |        创建一个新仓库        |
+|         create_repo          |   仓库   |         创建新仓库         |
-|          fork_repo           |   仓库   |         复刻一个仓库         |
+|          fork_repo           |   仓库   |          复刻仓库          |
-|        list_my_repos         |   仓库   | 列出已认证用户拥有的所有仓库 |
+|        list_my_repos         |   仓库   |      列出用户所有仓库      |
-|        create_branch         |   分支   |        创建一个新分支        |
+|        create_branch         |   分支   |         创建新分支         |
-|        delete_branch         |   分支   |         删除一个分支         |
+|        delete_branch         |   分支   |          删除分支          |
-|        list_branches         |   分支   |     列出仓库中的所有分支     |
+|        list_branches         |   分支   |        列出所有分支        |
-|        create_release        | 版本发布 |      创建一个新版本发布      |
+|        create_release        | 版本发布 |       创建新版本发布       |
-|        delete_release        | 版本发布 |       删除一个版本发布       |
+|        delete_release        | 版本发布 |        删除版本发布        |
-|         get_release          | 版本发布 |       获取一个版本发布       |
+|         get_release          | 版本发布 |        获取版本发布        |
-|      get_latest_release      | 版本发布 |      获取最新的版本发布      |
+|      get_latest_release      | 版本发布 |      获取最新版本发布      |
 |        list_releases         | 版本发布 |      列出所有版本发布      |
-|          create_tag          |   标签   |        创建一个新标签        |
+|          create_tag          |   标签   |         创建新标签         |
-|          delete_tag          |   标签   |         删除一个标签         |
+|          delete_tag          |   标签   |          删除标签          |
-|           get_tag            |   标签   |         获取一个标签         |
+|           get_tag            |   标签   |          获取标签          |
 |          list_tags           |   标签   |        列出所有标签        |
-|      list_repo_commits       |   提交   |     列出仓库中的所有提交     |
+|      list_repo_commits       |   提交   |        列出所有提交        |
-|       get_file_content       |   文件   |    获取文件的内容和元数据    |
+|       get_file_content       |   文件   |    获取文件内容和元数据    |
-|        get_dir_content       |   文件   |      获取目录的内容列表      |
+|       get_dir_content        |   文件   |      获取目录内容列表      |
-|         create_file          |   文件   |        创建一个新文件        |
+|         create_file          |   文件   |         创建新文件         |
 |         update_file          |   文件   |        更新现有文件        |
-|         delete_file          |   文件   |         删除一个文件         |
+|         delete_file          |   文件   |          删除文件          |
-|      get_issue_by_index      |   问题   |       根据索引获取问题       |
+|      get_issue_by_index      |   问题   |       按索引获取问题       |
-|       list_repo_issues       |   问题   |     列出仓库中的所有问题     |
+|       list_repo_issues       |   问题   |        列出所有问题        |
-|         create_issue         |   问题   |        创建一个新问题        |
+|         create_issue         |   问题   |         创建新问题         |
 |     create_issue_comment     |   问题   |      在问题上创建评论      |
-|          edit_issue          |   问题   |         编辑一个问题         |
+|          edit_issue          |   问题   |          编辑问题          |
-|      edit_issue_comment      |   问题   |      在问题上编辑评论         |
+|      edit_issue_comment      |   问题   |        编辑问题评论        |
-| get_issue_comments_by_index  |   问题   |     根据索引获取问题的评论     |
+| get_issue_comments_by_index  |   问题   |     按索引获取问题评论     |
-|  get_pull_request_by_index   | 拉取请求 |     根据索引获取拉取请求     |
+|  get_pull_request_by_index   | 拉取请求 |     按索引获取拉取请求     |
-|   list_repo_pull_requests    | 拉取请求 |   列出仓库中的所有拉取请求   |
+|   list_repo_pull_requests    | 拉取请求 |      列出所有拉取请求      |
-|     create_pull_request      | 拉取请求 |      创建一个新拉取请求      |
+|     create_pull_request      | 拉取请求 |       创建新拉取请求       |
+| create_pull_request_reviewer | 拉取请求 |     为拉取请求添加审查者   |
 |         search_users         |   用户   |          搜索用户          |
-|       search_org_teams       |   组织   |       搜索组织中的团队       |
+|       search_org_teams       |   组织   |        搜索组织团队        |
+|       list_org_labels        |   组织   |        列出组织标签        |
+|       create_org_label       |   组织   |        创建组织标签        |
+|        edit_org_label        |   组织   |        编辑组织标签        |
+|       delete_org_label       |   组织   |        删除组织标签        |
 |         search_repos         |   仓库   |          搜索仓库          |
-| get_gitea_mcp_server_version |   服务器    |        获取 Gitea MCP 服务器的版本         |
+| get_gitea_mcp_server_version |  服务器  | 获取 Gitea MCP 服务器版本  |
+|       list_wiki_pages        |   Wiki   |     列出所有 Wiki 页面     |
+|        get_wiki_page         |   Wiki   | 获取 Wiki 页面内容和元数据 |
+|      get_wiki_revisions      |   Wiki   |     获取 Wiki 修订历史     |
+|       create_wiki_page       |   Wiki   |      创建新 Wiki 页面      |
+|       update_wiki_page       |   Wiki   |     更新现有 Wiki 页面     |
+|       delete_wiki_page       |   Wiki   |       删除 Wiki 页面       |
 
 ## 🐛 调试
 
-要启用调试模式，请在使用 sse 模式运行 Gitea MCP 服务器时添加 `-d` 标志：
+启用调试模式时，请在 http 模式运行 Gitea MCP 服务器时加上 `-d` 标志：
 
 ```sh
-./gitea-mcp -t sse [--port 8080] --token <your personal access token> -d
+./gitea-mcp -t http [--port 8080] --token <your personal access token> -d
 ```
 
 ## 🛠 疑难排解
 
-如果您遇到任何问题，以下是一些常见的疑难排解步骤：
+如遇问题，可参考以下步骤：
 
-1. **检查您的 PATH**: 确保 `gitea-mcp` 二进制文件位于系统 PATH 中包含的目录中。
+1. **检查 PATH**：确保 `gitea-mcp` 可执行文件已在系统 PATH 目录中。
-2. **验证依赖项**: 确保您已安装所有所需的依赖项，例如 `make` 和 `Golang`。
+2. **验证依赖**：确认已安装 `make` 和 `Golang` 等必要依赖。
-3. **检查配置**: 仔细检查您的 MCP 配置文件是否有任何错误或遗漏的信息。
+3. **检查配置**：仔细检查 MCP 配置文件是否有错误或遗漏。
-4. **查看日志**: 检查日志中是否有任何错误消息或警告，可以提供有关问题的更多信息。
+4. **查看日志**：检查日志消息或警告以获取更多信息。
 
-享受通过聊天探索和管理您的 Gitea 仓库的乐趣！
+享受通过聊天探索和管理您的 Gitea 仓库！

README.zh-tw.md

@@ -14,9 +14,9 @@
   - [什麼是 MCP？](#什麼是-mcp)
   - [🚧 安裝](#-安裝)
     - [在 VS Code 中使用](#在-vs-code-中使用)
-    - [📥 下載官方 Gitea MCP 二進位版本](#-下載官方-gitea-mcp-二進位版本)
+    - [📥 下載官方二進位版本](#-下載官方二進位版本)
-    - [🔧 從源代碼構建](#-從源代碼構建)
+    - [🔧 從原始碼建置](#-從原始碼建置)
-    - [📁 添加到 PATH](#-添加到-path)
+    - [📁 加入 PATH](#-加入-path)
   - [🚀 使用](#-使用)
   - [✅ 可用工具](#-可用工具)
   - [🐛 調試](#-調試)
@@ -24,23 +24,23 @@
 
 ## 什麼是 Gitea？
 
-Gitea 是一個由社群管理的輕量級代碼託管解決方案，使用 Go 語言編寫。它以 MIT 許可證發布。Gitea 提供 Git 託管，包括倉庫查看器、問題追蹤、拉取請求等功能。
+Gitea 是一個由社群管理的輕量級程式碼託管解決方案，使用 Go 語言編寫，採用 MIT 授權。Gitea 提供 Git 託管，包括倉庫瀏覽、議題追蹤、拉取請求等功能。
 
 ## 什麼是 MCP？
 
-Model Context Protocol (MCP) 是一種協議，允許通過聊天界面整合各種工具和系統。它能夠無縫執行命令和管理倉庫、用戶和其他資源。
+Model Context Protocol (MCP) 是一種協議，允許透過聊天介面整合各種工具與系統。它能夠無縫執行命令並管理倉庫、使用者及其他資源。
 
 ## 🚧 安裝
 
 ### 在 VS Code 中使用
 
-要快速安裝，請使用本 README 頂部的單擊安裝按鈕之一。
+欲快速安裝，請使用本 README 頂部的安裝按鈕。
 
-要手動安裝，請將以下 JSON 塊添加到 VS Code 的用戶設置 (JSON) 文件中。您可以通過按 `Ctrl + Shift + P` 並輸入 `Preferences: Open User Settings (JSON)` 來完成此操作。
+如需手動安裝，請將下列 JSON 區塊加入 VS Code 的使用者設定 (JSON) 檔案。可按 `Ctrl + Shift + P` 並輸入 `Preferences: Open User Settings (JSON)`。
 
-或者，您可以將其添加到工作區中的 `.vscode/mcp.json` 文件中。這將允許您與他人共享配置。
+也可加入至工作區的 `.vscode/mcp.json` 檔案，方便與他人共享設定。
 
-> 請注意，`.vscode/mcp.json` 文件中不需要 `mcp` 鍵。
+> `.vscode/mcp.json` 檔案不需 `mcp` 鍵。
 
 ```json
 {
@@ -49,7 +49,7 @@ Model Context Protocol (MCP) 是一種協議，允許通過聊天界面整合各
       {
         "type": "promptString",
         "id": "gitea_token",
-        "description": "Gitea 個人訪問令牌",
+        "description": "Gitea 個人存取令牌",
         "password": true
       }
     ],
@@ -73,32 +73,32 @@ Model Context Protocol (MCP) 是一種協議，允許通過聊天界面整合各
 }
 ```
 
-### 📥 下載官方 Gitea MCP 二進位版本
+### 📥 下載官方二進位版本
 
-您可以從[官方 Gitea MCP 二進位版本](https://gitea.com/gitea/gitea-mcp/releases)下載官方版本。
+可至 [官方 Gitea MCP 二進位版本](https://gitea.com/gitea/gitea-mcp/releases) 下載。
 
-### 🔧 從源代碼構建
+### 🔧 從原始碼建置
 
-您可以使用 Git 克隆倉庫來下載源代碼：
+可用 Git 下載原始碼：
 
 ```bash
 git clone https://gitea.com/gitea/gitea-mcp.git
 ```
 
-在構建之前，請確保您已安裝以下內容：
+建置前請先安裝：
 
 - make
-- Golang (建議使用 Go 1.24 或更高版本)
+- Golang（建議 Go 1.24 以上）
 
-然後運行：
+然後執行：
 
 ```bash
 make install
 ```
 
-### 📁 添加到 PATH
+### 📁 加入 PATH
 
-安裝後，將二進制文件 gitea-mcp 複製到系統 PATH 中包含的目錄。例如：
+安裝後，將 gitea-mcp 執行檔複製到系統 PATH 目錄，例如：
 
 ```bash
 cp gitea-mcp /usr/local/bin/
@@ -106,8 +106,8 @@ cp gitea-mcp /usr/local/bin/
 
 ## 🚀 使用
 
-此示例適用於 Cursor，您也可以在 VSCode 中使用插件。
+此範例適用於 Cursor，也可在 VSCode 使用插件。  
-要配置 Gitea 的 MCP 伺服器，請將以下內容添加到您的 MCP 配置文件中：
+欲設定 Gitea MCP 伺服器，請將下列內容加入 MCP 設定檔：
 
 - **stdio 模式**
 
@@ -133,25 +133,16 @@ cp gitea-mcp /usr/local/bin/
 }
 ```
 
-- **sse 模式**
-
-```json
-{
-  "mcpServers": {
-    "gitea": {
-      "url": "http://localhost:8080/sse"
-    }
-  }
-}
-```
-
 - **http 模式**
 
 ```json
 {
   "mcpServers": {
     "gitea": {
-      "url": "http://localhost:8080/mcp"
+      "url": "http://localhost:8080/mcp",
+      "headers": {
+        "Authorization": "Bearer <your personal access token>"
+      }
     }
   }
 }
@@ -160,10 +151,10 @@ cp gitea-mcp /usr/local/bin/
 **預設日誌路徑**: `$HOME/.gitea-mcp/gitea-mcp.log`
 
 > [!注意]
-> 您可以通過命令列參數或環境變數提供您的 Gitea 主機和訪問令牌。
+> 可用命令列參數或環境變數提供 Gitea 主機與存取令牌。  
-> 命令列參數具有最高優先權
+> 命令列參數優先。
 
-一切設置完成後，請嘗試在您的 MCP 兼容聊天框中輸入以下內容：
+一切設定完成後，可在 MCP 聊天框輸入：
 
 ```text
 列出我所有的倉庫
@@ -171,63 +162,74 @@ cp gitea-mcp /usr/local/bin/
 
 ## ✅ 可用工具
 
-Gitea MCP 伺服器支持以下工具：
+Gitea MCP 伺服器支援以下工具：
 
 |             工具             |   範圍   |             描述             |
 | :--------------------------: | :------: | :--------------------------: |
-|       get_my_user_info       |   用戶   |     獲取已認證用戶的信息     |
+|       get_my_user_info       |   用戶   |      取得已認證用戶資訊      |
 |        get_user_orgs         |   用戶   |    取得已認證用戶所屬組織    |
-|         create_repo          |   倉庫   |        創建一個新倉庫        |
+|         create_repo          |   倉庫   |          創建新倉庫          |
-|          fork_repo           |   倉庫   |         復刻一個倉庫         |
+|          fork_repo           |   倉庫   |           復刻倉庫           |
-|        list_my_repos         |   倉庫   | 列出已認證用戶擁有的所有倉庫 |
+|        list_my_repos         |   倉庫   |       列出用戶所有倉庫       |
-|        create_branch         |   分支   |        創建一個新分支        |
+|        create_branch         |   分支   |          創建新分支          |
-|        delete_branch         |   分支   |         刪除一個分支         |
+|        delete_branch         |   分支   |           刪除分支           |
-|        list_branches         |   分支   |     列出倉庫中的所有分支     |
+|        list_branches         |   分支   |         列出所有分支         |
-|        create_release        | 版本發布 |      創建一個新版本發布      |
+|        create_release        | 版本發布 |        創建新版本發布        |
-|        delete_release        | 版本發布 |       刪除一個版本發布       |
+|        delete_release        | 版本發布 |         刪除版本發布         |
-|         get_release          | 版本發布 |       獲取一個版本發布       |
+|         get_release          | 版本發布 |         取得版本發布         |
-|      get_latest_release      | 版本發布 |      獲取最新的版本發布      |
+|      get_latest_release      | 版本發布 |       取得最新版本發布       |
 |        list_releases         | 版本發布 |       列出所有版本發布       |
-|          create_tag          |   標籤   |        創建一個新標籤        |
+|          create_tag          |   標籤   |          創建新標籤          |
-|          delete_tag          |   標籤   |         刪除一個標籤         |
+|          delete_tag          |   標籤   |           刪除標籤           |
-|           get_tag            |   標籤   |         獲取一個標籤         |
+|           get_tag            |   標籤   |           取得標籤           |
 |          list_tags           |   標籤   |         列出所有標籤         |
-|      list_repo_commits       |   提交   |     列出倉庫中的所有提交     |
+|      list_repo_commits       |   提交   |         列出所有提交         |
-|       get_file_content       |   文件   |    獲取文件的內容和元數據    |
+|       get_file_content       |   文件   |    取得文件內容與中繼資料    |
-|        get_dir_content       |   文件   |      獲取目錄的內容列表      |
+|       get_dir_content        |   文件   |       取得目錄內容列表       |
-|         create_file          |   文件   |        創建一個新文件        |
+|         create_file          |   文件   |          創建新文件          |
 |         update_file          |   文件   |         更新現有文件         |
-|         delete_file          |   文件   |         刪除一個文件         |
+|         delete_file          |   文件   |           刪除文件           |
-|      get_issue_by_index      |   問題   |       根據索引獲取問題       |
+|      get_issue_by_index      |   問題   |        依索引取得問題        |
-|       list_repo_issues       |   問題   |     列出倉庫中的所有問題     |
+|       list_repo_issues       |   問題   |         列出所有問題         |
-|         create_issue         |   問題   |        創建一個新問題        |
+|         create_issue         |   問題   |          創建新問題          |
 |     create_issue_comment     |   問題   |       在問題上創建評論       |
-|          edit_issue          |   問題   |         編輯一個問題         |
+|          edit_issue          |   問題   |           編輯問題           |
-|      edit_issue_comment      |   問題   |      在問題上編輯評論         |
+|      edit_issue_comment      |   問題   |         編輯問題評論         |
-| get_issue_comments_by_index  |   问题   |     根據索引獲取問題的評論     |
+| get_issue_comments_by_index  |   問題   |      依索引取得問題評論      |
-|  get_pull_request_by_index   | 拉取請求 |     根據索引獲取拉取請求     |
+|  get_pull_request_by_index   | 拉取請求 |      依索引取得拉取請求      |
-|   list_repo_pull_requests    | 拉取請求 |   列出倉庫中的所有拉取請求   |
+|   list_repo_pull_requests    | 拉取請求 |       列出所有拉取請求       |
-|     create_pull_request      | 拉取請求 |      創建一個新拉取請求      |
+|     create_pull_request      | 拉取請求 |        創建新拉取請求        |
-|         search_users         |   用戶   |           搜索用戶           |
+| create_pull_request_reviewer | 拉取請求 |      為拉取請求添加審查者    |
-|       search_org_teams       |   組織   |       搜索組織中的團隊       |
+|         search_users         |   用戶   |           搜尋用戶           |
-|         search_repos         |   倉庫   |           搜索倉庫           |
+|       search_org_teams       |   組織   |         搜尋組織團隊         |
-| get_gitea_mcp_server_version |   伺服器    |        獲取 Gitea MCP 伺服器的版本         |
+|       list_org_labels        |   組織   |         列出組織標籤         |
+|       create_org_label       |   組織   |         創建組織標籤         |
+|        edit_org_label        |   組織   |         編輯組織標籤         |
+|       delete_org_label       |   組織   |         刪除組織標籤         |
+|         search_repos         |   倉庫   |           搜尋倉庫           |
+| get_gitea_mcp_server_version |  伺服器  |  取得 Gitea MCP 伺服器版本   |
+|       list_wiki_pages        |   Wiki   |      列出所有 Wiki 頁面      |
+|        get_wiki_page         |   Wiki   | 取得 Wiki 頁面內容與中繼資料 |
+|      get_wiki_revisions      |   Wiki   |      取得 Wiki 修訂歷史      |
+|       create_wiki_page       |   Wiki   |       創建新 Wiki 頁面       |
+|       update_wiki_page       |   Wiki   |      更新現有 Wiki 頁面      |
+|       delete_wiki_page       |   Wiki   |        刪除 Wiki 頁面        |
 
 ## 🐛 調試
 
-要啟用調試模式，請在使用 sse 模式運行 Gitea MCP 伺服器時添加 `-d` 旗標：
+啟用調試模式時，請在 http 模式執行 Gitea MCP 伺服器時加上 `-d` 旗標：
 
 ```sh
-./gitea-mcp -t sse [--port 8080] --token <your personal access token> -d
+./gitea-mcp -t http [--port 8080] --token <your personal access token> -d
 ```
 
 ## 🛠 疑難排解
 
-如果您遇到任何問題，以下是一些常見的疑難排解步驟：
+如遇問題，可參考以下步驟：
 
-1. **檢查您的 PATH**: 確保 `gitea-mcp` 二進制文件位於系統 PATH 中包含的目錄中。
+1. **檢查 PATH**：確保 `gitea-mcp` 執行檔已在系統 PATH 目錄中。
-2. **驗證依賴項**: 確保您已安裝所有所需的依賴項，例如 `make` 和 `Golang`。
+2. **驗證依賴**：確認已安裝 `make` 與 `Golang` 等必要依賴。
-3. **檢查配置**: 仔細檢查您的 MCP 配置文件是否有任何錯誤或遺漏的信息。
+3. **檢查設定**：仔細檢查 MCP 設定檔是否有錯誤或遺漏。
-4. **查看日誌**: 檢查日誌中是否有任何錯誤消息或警告，可以提供有關問題的更多信息。
+4. **查看日誌**：檢查日誌訊息或警告以獲取更多資訊。
 
-享受通過聊天探索和管理您的 Gitea 倉庫的樂趣！
+享受透過聊天探索與管理您的 Gitea 倉庫！

build.bat

@@ -0,0 +1,2 @@
+@echo off
+powershell -ExecutionPolicy Bypass -File "%~dp0build.ps1" %*

build.ps1

@@ -0,0 +1,220 @@
+#!/usr/bin/env pwsh
+
+# PowerShell build script for gitea-mcp
+# Replicates the functionality of the Makefile
+
+param(
+    [string]$Target = "help"
+)
+
+# Configuration
+$EXECUTABLE = "gitea-mcp.exe"
+$VERSION = & git describe --tags --always 2>$null | ForEach-Object { $_ -replace '-', '+' -replace '^v', '' }
+if (-not $VERSION) { $VERSION = "dev" }
+$LDFLAGS = "-X `"main.Version=$VERSION`""
+
+# Colors for output (Windows PowerShell compatible)
+$CYAN = "Cyan"
+$RESET = "White"
+
+function Write-Header {
+    param([string]$Message)
+    Write-Host "=== $Message ===" -ForegroundColor Green
+}
+
+function Write-Info {
+    param([string]$Message)
+    Write-Host $Message -ForegroundColor Yellow
+}
+
+function Write-Success {
+    param([string]$Message)
+    Write-Host $Message -ForegroundColor Green
+}
+
+function Write-Error {
+    param([string]$Message)
+    Write-Host $Message -ForegroundColor Red
+}
+
+function Get-Help {
+    Write-Host "Usage: .\build.ps1 [target]" -ForegroundColor Green
+    Write-Host ""
+    Write-Host "Targets:" -ForegroundColor Green
+    Write-Host ""
+    
+    Write-Host ("{0,-30}" -f "help") -ForegroundColor Cyan -NoNewline
+    Write-Host " Print this help message."
+    Write-Host ("{0,-30}" -f "build") -ForegroundColor Cyan -NoNewline
+    Write-Host " Build the application."
+    Write-Host ("{0,-30}" -f "install") -ForegroundColor Cyan -NoNewline
+    Write-Host " Install the application."
+    Write-Host ("{0,-30}" -f "uninstall") -ForegroundColor Cyan -NoNewline
+    Write-Host " Uninstall the application."
+    Write-Host ("{0,-30}" -f "clean") -ForegroundColor Cyan -NoNewline
+    Write-Host " Clean the build artifacts."
+    Write-Host ("{0,-30}" -f "air") -ForegroundColor Cyan -NoNewline
+    Write-Host " Install air for hot reload."
+    Write-Host ("{0,-30}" -f "dev") -ForegroundColor Cyan -NoNewline
+    Write-Host " Run the application with hot reload."
+    Write-Host ("{0,-30}" -f "vendor") -ForegroundColor Cyan -NoNewline
+    Write-Host " Tidy and verify module dependencies."
+}
+
+function Build-App {
+    Write-Header "Building application"
+    
+    $ldflags = "-s -w $LDFLAGS"
+    Write-Info "go build -v -ldflags '$ldflags' -o $EXECUTABLE"
+    
+    try {
+        & go build -v -ldflags $ldflags -o $EXECUTABLE
+        if ($LASTEXITCODE -eq 0) {
+            Write-Success "Build successful: $EXECUTABLE"
+        } else {
+            Write-Error "Build failed with exit code: $LASTEXITCODE"
+            exit $LASTEXITCODE
+        }
+    } catch {
+        Write-Error "Build failed: $_"
+        exit 1
+    }
+}
+
+function Install-App {
+    Write-Header "Installing application"
+    
+    # First build the application
+    Build-App
+    
+    $GOPATH = $env:GOPATH
+    if (-not $GOPATH) {
+        $GOPATH = Join-Path $env:USERPROFILE "go"
+    }
+    
+    $installDir = Join-Path $GOPATH "bin"
+    $installPath = Join-Path $installDir $EXECUTABLE
+    
+    Write-Info "Installing $EXECUTABLE to $installPath"
+    
+    # Create directory if it doesn't exist
+    if (-not (Test-Path $installDir)) {
+        New-Item -ItemType Directory -Path $installDir -Force | Out-Null
+    }
+    
+    # Copy the executable
+    if (Test-Path $EXECUTABLE) {
+        Copy-Item $EXECUTABLE $installPath -Force
+        Write-Success "Installed $EXECUTABLE to $installPath"
+        Write-Info "Please add $installDir to your PATH if it is not already there."
+    } else {
+        Write-Error "Executable not found. Please build first."
+        exit 1
+    }
+}
+
+function Uninstall-App {
+    Write-Header "Uninstalling application"
+    
+    $GOPATH = $env:GOPATH
+    if (-not $GOPATH) {
+        $GOPATH = Join-Path $env:USERPROFILE "go"
+    }
+    
+    $installPath = Join-Path $GOPATH "bin" $EXECUTABLE
+    
+    Write-Info "Uninstalling $EXECUTABLE from $installPath"
+    
+    if (Test-Path $installPath) {
+        Remove-Item $installPath -Force
+        Write-Success "Uninstalled $EXECUTABLE from $installPath"
+    } else {
+        Write-Warning "$EXECUTABLE not found at $installPath"
+    }
+}
+
+function Clean-Build {
+    Write-Header "Cleaning build artifacts"
+    
+    Write-Info "Cleaning up $EXECUTABLE"
+    
+    if (Test-Path $EXECUTABLE) {
+        Remove-Item $EXECUTABLE -Force
+        Write-Success "Cleaned up $EXECUTABLE"
+    } else {
+        Write-Warning "$EXECUTABLE not found"
+    }
+}
+
+function Install-Air {
+    Write-Header "Installing air for hot reload"
+    
+    # Check if air is already installed
+    $airPath = Get-Command air -ErrorAction SilentlyContinue
+    if ($airPath) {
+        Write-Success "air is already installed"
+        return
+    }
+    
+    Write-Info "Installing github.com/air-verse/air@latest"
+    try {
+        & go install github.com/air-verse/air@latest
+        if ($LASTEXITCODE -eq 0) {
+            Write-Success "air installed successfully"
+        } else {
+            Write-Error "Failed to install air"
+            exit $LASTEXITCODE
+        }
+    } catch {
+        Write-Error "Failed to install air: $_"
+        exit 1
+    }
+}
+
+function Start-Dev {
+    Write-Header "Starting development mode with hot reload"
+    
+    # Install air first
+    Install-Air
+    
+    Write-Info "Starting air with build configuration"
+    & air --build.cmd "go build -o $EXECUTABLE" --build.bin "./$EXECUTABLE"
+}
+
+function Update-Vendor {
+    Write-Header "Tidying and verifying module dependencies"
+    
+    Write-Info "Running go mod tidy"
+    & go mod tidy
+    if ($LASTEXITCODE -ne 0) {
+        Write-Error "go mod tidy failed"
+        exit $LASTEXITCODE
+    }
+    
+    Write-Info "Running go mod verify"
+    & go mod verify
+    if ($LASTEXITCODE -ne 0) {
+        Write-Error "go mod verify failed"
+        exit $LASTEXITCODE
+    }
+    
+    Write-Success "Dependencies updated successfully"
+}
+
+# Main execution logic
+switch ($Target.ToLower()) {
+    "help" { Get-Help }
+    "build" { Build-App }
+    "install" { Install-App }
+    "uninstall" { Uninstall-App }
+    "clean" { Clean-Build }
+    "air" { Install-Air }
+    "dev" { Start-Dev }
+    "vendor" { Update-Vendor }
+    default {
+        Write-Error "Unknown target: $Target"
+        Write-Host ""
+        Get-Help
+        exit 1
+    }
+}

cmd/cmd.go

@@ -21,13 +21,13 @@ func init() {
 		&flagPkg.Mode,
 		"t",
 		"stdio",
-		"Transport type (stdio, sse or http)",
+		"Transport type (stdio or http)",
 	)
 	flag.StringVar(
 		&flagPkg.Mode,
 		"transport",
 		"stdio",
-		"Transport type (stdio, sse or http)",
+		"Transport type (stdio or http)",
 	)
 	flag.StringVar(
 		&host,
@@ -39,7 +39,7 @@ func init() {
 		&port,
 		"port",
 		8080,
-		"see or http port",
+		"http port",
 	)
 	flag.StringVar(
 		&token,

config.json

@@ -2,11 +2,11 @@
   "mcpServers": {
     "gitea": {
       "command": "gitea-mcp",
-      "args": {
+      "args": [
-        "-t": "stdio",
+        "-t", "stdio",
-        "--host": "https://gitea.com",
+        "--host", "https://gitea.com",
-        "--token": "<your personal access token>"
+        "--token", "<your personal access token>"
-      },
+      ]
       "env": {
         "GITEA_HOST": "https://gitea.com",
         "GITEA_ACCESS_TOKEN": "<your personal access token>"

go.mod

@@ -3,21 +3,27 @@ module gitea.com/gitea/gitea-mcp
 go 1.24.0
 
 require (
-	code.gitea.io/sdk/gitea v0.21.0
+	code.gitea.io/sdk/gitea v0.22.1
-	github.com/mark3labs/mcp-go v0.35.0
+	github.com/mark3labs/mcp-go v0.42.0
 	go.uber.org/zap v1.27.0
 	gopkg.in/natefinch/lumberjack.v2 v2.2.1
 )
 
 require (
 	github.com/42wim/httpsig v1.2.3 // indirect
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
+	github.com/buger/jsonparser v1.1.1 // indirect
 	github.com/davidmz/go-pageant v1.0.2 // indirect
 	github.com/go-fed/httpsig v1.1.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/hashicorp/go-version v1.7.0 // indirect
-	github.com/spf13/cast v1.9.2 // indirect
+	github.com/invopop/jsonschema v0.13.0 // indirect
+	github.com/mailru/easyjson v0.9.1 // indirect
+	github.com/spf13/cast v1.10.0 // indirect
+	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
 	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.40.0 // indirect
+	golang.org/x/crypto v0.43.0 // indirect
-	golang.org/x/sys v0.34.0 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,7 +1,11 @@
-code.gitea.io/sdk/gitea v0.21.0 h1:69n6oz6kEVHRo1+APQQyizkhrZrLsTLXey9142pfkD4=
+code.gitea.io/sdk/gitea v0.22.1 h1:7K05KjRORyTcTYULQ/AwvlVS6pawLcWyXZcTr7gHFyA=
-code.gitea.io/sdk/gitea v0.21.0/go.mod h1:tnBjVhuKJCn8ibdyyhvUyxrR1Ca2KHEoTWoukNhXQPA=
+code.gitea.io/sdk/gitea v0.22.1/go.mod h1:yyF5+GhljqvA30sRDreoyHILruNiy4ASufugzYg0VHM=
 github.com/42wim/httpsig v1.2.3 h1:xb0YyWhkYj57SPtfSttIobJUPJZB9as1nsfo7KWVcEs=
 github.com/42wim/httpsig v1.2.3/go.mod h1:nZq9OlYKDrUBhptd77IHx4/sZZD+IxTBADvAPI9G/EM=
+github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
+github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
+github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
+github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davidmz/go-pageant v1.0.2 h1:bPblRCh5jGU+Uptpz6LgMZGD5hJoOt7otgT454WvHn0=
@@ -16,20 +20,26 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
 github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/invopop/jsonschema v0.13.0 h1:KvpoAJWEjR3uD9Kbm2HWJmqsEaHt8lBUpd0qHcIi21E=
+github.com/invopop/jsonschema v0.13.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mark3labs/mcp-go v0.35.0 h1:eh5bJGGVkNEaehCbPmAFqFgk/SB18YvxmsR2rnPm8BQ=
+github.com/mailru/easyjson v0.9.1 h1:LbtsOm5WAswyWbvTEOqhypdPeZzHavpZx96/n553mR8=
-github.com/mark3labs/mcp-go v0.35.0/go.mod h1:rXqOudj/djTORU/ThxYx8fqEVj/5pvTuuebQ2RC7uk4=
+github.com/mailru/easyjson v0.9.1/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU=
+github.com/mark3labs/mcp-go v0.42.0 h1:gk/8nYJh8t3yroCAOBhNbYsM9TCKvkM13I5t5Hfu6Ls=
+github.com/mark3labs/mcp-go v0.42.0/go.mod h1:YnJfOL382MIWDx1kMY+2zsRHU/q78dBg9aFb8W6Thdw=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
-github.com/spf13/cast v1.9.2 h1:SsGfm7M8QOFtEzumm7UZrZdLLquNdzFYfIbEXntcFbE=
+github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
-github.com/spf13/cast v1.9.2/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
+github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
+github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
 github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
 github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
@@ -41,21 +51,23 @@ go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
-golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
+golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
-golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
+golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
-golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.33.0 h1:NuFncQrRcaRvVmgRkvM3j/F00gWIAlcmlB8ACEKmGIg=
+golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
-golang.org/x/term v0.33.0/go.mod h1:s18+ql9tYWp1IfpV9DmCtQDDSRBUjKaw9M1eAv5UeF0=
+golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
 gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

operation/actions/actions.go

@@ -0,0 +1,10 @@
+package actions
+
+import (
+	"gitea.com/gitea/gitea-mcp/pkg/tool"
+)
+
+// Tool is the registry for all Actions-related MCP tools.
+var Tool = tool.New()
+
+

operation/actions/logs.go

@@ -0,0 +1,198 @@
+package actions
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/log"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+const (
+	GetRepoActionJobLogPreviewToolName = "get_repo_action_job_log_preview"
+	DownloadRepoActionJobLogToolName   = "download_repo_action_job_log"
+)
+
+var (
+	GetRepoActionJobLogPreviewTool = mcp.NewTool(
+		GetRepoActionJobLogPreviewToolName,
+		mcp.WithDescription("Get a repository Actions job log preview (tail/limited for chat-friendly output)"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("job_id", mcp.Required(), mcp.Description("job ID")),
+		mcp.WithNumber("tail_lines", mcp.Description("number of lines from the end of the log"), mcp.DefaultNumber(200), mcp.Min(1)),
+		mcp.WithNumber("max_bytes", mcp.Description("max bytes to return"), mcp.DefaultNumber(65536), mcp.Min(1024)),
+	)
+
+	DownloadRepoActionJobLogTool = mcp.NewTool(
+		DownloadRepoActionJobLogToolName,
+		mcp.WithDescription("Download a repository Actions job log to a file on the MCP server filesystem"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("job_id", mcp.Required(), mcp.Description("job ID")),
+		mcp.WithString("output_path", mcp.Description("optional output file path; if omitted, uses ~/.gitea-mcp/artifacts/actions-logs/...")),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(server.ServerTool{Tool: GetRepoActionJobLogPreviewTool, Handler: GetRepoActionJobLogPreviewFn})
+	Tool.RegisterRead(server.ServerTool{Tool: DownloadRepoActionJobLogTool, Handler: DownloadRepoActionJobLogFn})
+}
+
+func logPaths(owner, repo string, jobID int64) []string {
+	// Primary candidate endpoints, plus a few commonly-seen variants across versions.
+	// We try these in order; 404/405 falls through.
+	return []string{
+		fmt.Sprintf("repos/%s/%s/actions/jobs/%d/logs", url.PathEscape(owner), url.PathEscape(repo), jobID),
+		fmt.Sprintf("repos/%s/%s/actions/jobs/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
+		fmt.Sprintf("repos/%s/%s/actions/tasks/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
+		fmt.Sprintf("repos/%s/%s/actions/task/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
+	}
+}
+
+func fetchJobLogBytes(ctx context.Context, owner, repo string, jobID int64) ([]byte, string, error) {
+	var lastErr error
+	for _, p := range logPaths(owner, repo, jobID) {
+		b, _, err := gitea.DoBytes(ctx, "GET", p, nil, nil, "text/plain")
+		if err == nil {
+			return b, p, nil
+		}
+		lastErr = err
+		var httpErr *gitea.HTTPError
+		if errors.As(err, &httpErr) && (httpErr.StatusCode == 404 || httpErr.StatusCode == 405) {
+			continue
+		}
+		return nil, p, err
+	}
+	return nil, "", lastErr
+}
+
+func tailByLines(data []byte, tailLines int) []byte {
+	if tailLines <= 0 || len(data) == 0 {
+		return data
+	}
+	// Find the start index of the last N lines by scanning backwards.
+	lines := 0
+	i := len(data) - 1
+	for i >= 0 {
+		if data[i] == '\n' {
+			lines++
+			if lines > tailLines {
+				return data[i+1:]
+			}
+		}
+		i--
+	}
+	return data
+}
+
+func limitBytes(data []byte, maxBytes int) ([]byte, bool) {
+	if maxBytes <= 0 {
+		return data, false
+	}
+	if len(data) <= maxBytes {
+		return data, false
+	}
+	// Keep the tail so the most recent log content is preserved.
+	return data[len(data)-maxBytes:], true
+}
+
+func GetRepoActionJobLogPreviewFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetRepoActionJobLogPreviewFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	jobIDFloat, ok := req.GetArguments()["job_id"].(float64)
+	if !ok || jobIDFloat <= 0 {
+		return to.ErrorResult(fmt.Errorf("job_id is required"))
+	}
+	tailLinesFloat, _ := req.GetArguments()["tail_lines"].(float64)
+	maxBytesFloat, _ := req.GetArguments()["max_bytes"].(float64)
+	tailLines := int(tailLinesFloat)
+	if tailLines <= 0 {
+		tailLines = 200
+	}
+	maxBytes := int(maxBytesFloat)
+	if maxBytes <= 0 {
+		maxBytes = 65536
+	}
+
+	jobID := int64(jobIDFloat)
+	raw, usedPath, err := fetchJobLogBytes(ctx, owner, repo, jobID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get job log err: %v", err))
+	}
+
+	tailed := tailByLines(raw, tailLines)
+	limited, truncated := limitBytes(tailed, maxBytes)
+
+	return to.TextResult(map[string]any{
+		"endpoint":     usedPath,
+		"job_id":       jobID,
+		"bytes":        len(raw),
+		"tail_lines":   tailLines,
+		"max_bytes":    maxBytes,
+		"truncated":    truncated,
+		"log":          string(limited),
+	})
+}
+
+func DownloadRepoActionJobLogFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DownloadRepoActionJobLogFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	jobIDFloat, ok := req.GetArguments()["job_id"].(float64)
+	if !ok || jobIDFloat <= 0 {
+		return to.ErrorResult(fmt.Errorf("job_id is required"))
+	}
+	outputPath, _ := req.GetArguments()["output_path"].(string)
+	jobID := int64(jobIDFloat)
+
+	raw, usedPath, err := fetchJobLogBytes(ctx, owner, repo, jobID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("download job log err: %v", err))
+	}
+
+	if outputPath == "" {
+		home, _ := os.UserHomeDir()
+		if home == "" {
+			home = os.TempDir()
+		}
+		outputPath = filepath.Join(home, ".gitea-mcp", "artifacts", "actions-logs", owner, repo, fmt.Sprintf("%d.log", jobID))
+	}
+
+	if err := os.MkdirAll(filepath.Dir(outputPath), 0o700); err != nil {
+		return to.ErrorResult(fmt.Errorf("create output dir err: %v", err))
+	}
+	if err := os.WriteFile(outputPath, raw, 0o600); err != nil {
+		return to.ErrorResult(fmt.Errorf("write log file err: %v", err))
+	}
+
+	return to.TextResult(map[string]any{
+		"endpoint": usedPath,
+		"job_id":   jobID,
+		"path":     outputPath,
+		"bytes":    len(raw),
+	})
+}
+
+

operation/actions/logs_test.go

@@ -0,0 +1,24 @@
+package actions
+
+import "testing"
+
+func TestTailByLines(t *testing.T) {
+	in := []byte("a\nb\nc\nd\n")
+	got := string(tailByLines(in, 2))
+	if got != "c\nd\n" {
+		t.Fatalf("tailByLines(...,2) = %q", got)
+	}
+}
+
+func TestLimitBytesKeepsTail(t *testing.T) {
+	in := []byte("0123456789")
+	out, truncated := limitBytes(in, 4)
+	if !truncated {
+		t.Fatalf("expected truncated=true")
+	}
+	if string(out) != "6789" {
+		t.Fatalf("limitBytes tail = %q, want %q", string(out), "6789")
+	}
+}
+
+

operation/actions/runs.go

@@ -0,0 +1,468 @@
+package actions
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/log"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+const (
+	ListRepoActionWorkflowsToolName    = "list_repo_action_workflows"
+	GetRepoActionWorkflowToolName      = "get_repo_action_workflow"
+	DispatchRepoActionWorkflowToolName = "dispatch_repo_action_workflow"
+
+	ListRepoActionRunsToolName  = "list_repo_action_runs"
+	GetRepoActionRunToolName    = "get_repo_action_run"
+	CancelRepoActionRunToolName = "cancel_repo_action_run"
+	RerunRepoActionRunToolName  = "rerun_repo_action_run"
+
+	ListRepoActionJobsToolName    = "list_repo_action_jobs"
+	ListRepoActionRunJobsToolName = "list_repo_action_run_jobs"
+)
+
+var (
+	ListRepoActionWorkflowsTool = mcp.NewTool(
+		ListRepoActionWorkflowsToolName,
+		mcp.WithDescription("List repository Actions workflows"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(50), mcp.Min(1)),
+	)
+
+	GetRepoActionWorkflowTool = mcp.NewTool(
+		GetRepoActionWorkflowToolName,
+		mcp.WithDescription("Get a repository Actions workflow by ID"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("workflow_id", mcp.Required(), mcp.Description("workflow ID")),
+	)
+
+	DispatchRepoActionWorkflowTool = mcp.NewTool(
+		DispatchRepoActionWorkflowToolName,
+		mcp.WithDescription("Trigger (dispatch) a repository Actions workflow"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("workflow_id", mcp.Required(), mcp.Description("workflow ID")),
+		mcp.WithString("ref", mcp.Required(), mcp.Description("git ref (branch or tag)")),
+		mcp.WithObject("inputs", mcp.Description("workflow inputs object")),
+	)
+
+	ListRepoActionRunsTool = mcp.NewTool(
+		ListRepoActionRunsToolName,
+		mcp.WithDescription("List repository Actions workflow runs"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(50), mcp.Min(1)),
+		mcp.WithString("status", mcp.Description("optional status filter")),
+	)
+
+	GetRepoActionRunTool = mcp.NewTool(
+		GetRepoActionRunToolName,
+		mcp.WithDescription("Get a repository Actions run by ID"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("run_id", mcp.Required(), mcp.Description("run ID")),
+	)
+
+	CancelRepoActionRunTool = mcp.NewTool(
+		CancelRepoActionRunToolName,
+		mcp.WithDescription("Cancel a repository Actions run"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("run_id", mcp.Required(), mcp.Description("run ID")),
+	)
+
+	RerunRepoActionRunTool = mcp.NewTool(
+		RerunRepoActionRunToolName,
+		mcp.WithDescription("Rerun a repository Actions run"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("run_id", mcp.Required(), mcp.Description("run ID")),
+	)
+
+	ListRepoActionJobsTool = mcp.NewTool(
+		ListRepoActionJobsToolName,
+		mcp.WithDescription("List repository Actions jobs"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(50), mcp.Min(1)),
+		mcp.WithString("status", mcp.Description("optional status filter")),
+	)
+
+	ListRepoActionRunJobsTool = mcp.NewTool(
+		ListRepoActionRunJobsToolName,
+		mcp.WithDescription("List Actions jobs for a specific run"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("run_id", mcp.Required(), mcp.Description("run ID")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(50), mcp.Min(1)),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionWorkflowsTool, Handler: ListRepoActionWorkflowsFn})
+	Tool.RegisterRead(server.ServerTool{Tool: GetRepoActionWorkflowTool, Handler: GetRepoActionWorkflowFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: DispatchRepoActionWorkflowTool, Handler: DispatchRepoActionWorkflowFn})
+
+	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionRunsTool, Handler: ListRepoActionRunsFn})
+	Tool.RegisterRead(server.ServerTool{Tool: GetRepoActionRunTool, Handler: GetRepoActionRunFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: CancelRepoActionRunTool, Handler: CancelRepoActionRunFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: RerunRepoActionRunTool, Handler: RerunRepoActionRunFn})
+
+	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionJobsTool, Handler: ListRepoActionJobsFn})
+	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionRunJobsTool, Handler: ListRepoActionRunJobsFn})
+}
+
+func doJSONWithFallback(ctx context.Context, method string, paths []string, query url.Values, body any, respOut any) (string, int, error) {
+	var lastErr error
+	for _, p := range paths {
+		status, err := gitea.DoJSON(ctx, method, p, query, body, respOut)
+		if err == nil {
+			return p, status, nil
+		}
+		lastErr = err
+		var httpErr *gitea.HTTPError
+		if errors.As(err, &httpErr) && (httpErr.StatusCode == 404 || httpErr.StatusCode == 405) {
+			continue
+		}
+		return p, status, err
+	}
+	return "", 0, lastErr
+}
+
+func ListRepoActionWorkflowsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListRepoActionWorkflowsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	page, _ := req.GetArguments()["page"].(float64)
+	if page <= 0 {
+		page = 1
+	}
+	pageSize, _ := req.GetArguments()["pageSize"].(float64)
+	if pageSize <= 0 {
+		pageSize = 50
+	}
+	query := url.Values{}
+	query.Set("page", fmt.Sprintf("%d", int(page)))
+	query.Set("limit", fmt.Sprintf("%d", int(pageSize)))
+
+	var result any
+	_, _, err := doJSONWithFallback(ctx, "GET",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/workflows", url.PathEscape(owner), url.PathEscape(repo)),
+		},
+		query, nil, &result,
+	)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list action workflows err: %v", err))
+	}
+	return to.TextResult(result)
+}
+
+func GetRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetRepoActionWorkflowFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	workflowID, ok := req.GetArguments()["workflow_id"].(float64)
+	if !ok || workflowID <= 0 {
+		return to.ErrorResult(fmt.Errorf("workflow_id is required"))
+	}
+
+	var result any
+	_, _, err := doJSONWithFallback(ctx, "GET",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/workflows/%d", url.PathEscape(owner), url.PathEscape(repo), int64(workflowID)),
+		},
+		nil, nil, &result,
+	)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get action workflow err: %v", err))
+	}
+	return to.TextResult(result)
+}
+
+func DispatchRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DispatchRepoActionWorkflowFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	workflowID, ok := req.GetArguments()["workflow_id"].(float64)
+	if !ok || workflowID <= 0 {
+		return to.ErrorResult(fmt.Errorf("workflow_id is required"))
+	}
+	ref, ok := req.GetArguments()["ref"].(string)
+	if !ok || ref == "" {
+		return to.ErrorResult(fmt.Errorf("ref is required"))
+	}
+
+	var inputs map[string]any
+	if raw, exists := req.GetArguments()["inputs"]; exists {
+		if m, ok := raw.(map[string]any); ok {
+			inputs = m
+		} else if m, ok := raw.(map[string]interface{}); ok {
+			inputs = make(map[string]any, len(m))
+			for k, v := range m {
+				inputs[k] = v
+			}
+		}
+	}
+
+	body := map[string]any{
+		"ref": ref,
+	}
+	if inputs != nil {
+		body["inputs"] = inputs
+	}
+
+	_, _, err := doJSONWithFallback(ctx, "POST",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/workflows/%d/dispatches", url.PathEscape(owner), url.PathEscape(repo), int64(workflowID)),
+			fmt.Sprintf("repos/%s/%s/actions/workflows/%d/dispatch", url.PathEscape(owner), url.PathEscape(repo), int64(workflowID)),
+		},
+		nil, body, nil,
+	)
+	if err != nil {
+		var httpErr *gitea.HTTPError
+		if errors.As(err, &httpErr) && (httpErr.StatusCode == 404 || httpErr.StatusCode == 405) {
+			return to.ErrorResult(fmt.Errorf("workflow dispatch not supported on this Gitea version (endpoint returned %d). Check https://docs.gitea.com/api/1.24/ for available Actions endpoints", httpErr.StatusCode))
+		}
+		return to.ErrorResult(fmt.Errorf("dispatch action workflow err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "workflow dispatched"})
+}
+
+func ListRepoActionRunsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListRepoActionRunsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	page, _ := req.GetArguments()["page"].(float64)
+	if page <= 0 {
+		page = 1
+	}
+	pageSize, _ := req.GetArguments()["pageSize"].(float64)
+	if pageSize <= 0 {
+		pageSize = 50
+	}
+	statusFilter, _ := req.GetArguments()["status"].(string)
+
+	query := url.Values{}
+	query.Set("page", fmt.Sprintf("%d", int(page)))
+	query.Set("limit", fmt.Sprintf("%d", int(pageSize)))
+	if statusFilter != "" {
+		query.Set("status", statusFilter)
+	}
+
+	var result any
+	_, _, err := doJSONWithFallback(ctx, "GET",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/runs", url.PathEscape(owner), url.PathEscape(repo)),
+		},
+		query, nil, &result,
+	)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list action runs err: %v", err))
+	}
+	return to.TextResult(result)
+}
+
+func GetRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetRepoActionRunFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	runID, ok := req.GetArguments()["run_id"].(float64)
+	if !ok || runID <= 0 {
+		return to.ErrorResult(fmt.Errorf("run_id is required"))
+	}
+
+	var result any
+	_, _, err := doJSONWithFallback(ctx, "GET",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/runs/%d", url.PathEscape(owner), url.PathEscape(repo), int64(runID)),
+		},
+		nil, nil, &result,
+	)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get action run err: %v", err))
+	}
+	return to.TextResult(result)
+}
+
+func CancelRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called CancelRepoActionRunFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	runID, ok := req.GetArguments()["run_id"].(float64)
+	if !ok || runID <= 0 {
+		return to.ErrorResult(fmt.Errorf("run_id is required"))
+	}
+
+	_, _, err := doJSONWithFallback(ctx, "POST",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/runs/%d/cancel", url.PathEscape(owner), url.PathEscape(repo), int64(runID)),
+		},
+		nil, nil, nil,
+	)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("cancel action run err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "run cancellation requested"})
+}
+
+func RerunRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called RerunRepoActionRunFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	runID, ok := req.GetArguments()["run_id"].(float64)
+	if !ok || runID <= 0 {
+		return to.ErrorResult(fmt.Errorf("run_id is required"))
+	}
+
+	_, _, err := doJSONWithFallback(ctx, "POST",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/runs/%d/rerun", url.PathEscape(owner), url.PathEscape(repo), int64(runID)),
+			fmt.Sprintf("repos/%s/%s/actions/runs/%d/rerun-failed-jobs", url.PathEscape(owner), url.PathEscape(repo), int64(runID)),
+		},
+		nil, nil, nil,
+	)
+	if err != nil {
+		var httpErr *gitea.HTTPError
+		if errors.As(err, &httpErr) && (httpErr.StatusCode == 404 || httpErr.StatusCode == 405) {
+			return to.ErrorResult(fmt.Errorf("workflow rerun not supported on this Gitea version (endpoint returned %d). Check https://docs.gitea.com/api/1.24/ for available Actions endpoints", httpErr.StatusCode))
+		}
+		return to.ErrorResult(fmt.Errorf("rerun action run err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "run rerun requested"})
+}
+
+func ListRepoActionJobsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListRepoActionJobsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	page, _ := req.GetArguments()["page"].(float64)
+	if page <= 0 {
+		page = 1
+	}
+	pageSize, _ := req.GetArguments()["pageSize"].(float64)
+	if pageSize <= 0 {
+		pageSize = 50
+	}
+	statusFilter, _ := req.GetArguments()["status"].(string)
+
+	query := url.Values{}
+	query.Set("page", fmt.Sprintf("%d", int(page)))
+	query.Set("limit", fmt.Sprintf("%d", int(pageSize)))
+	if statusFilter != "" {
+		query.Set("status", statusFilter)
+	}
+
+	var result any
+	_, _, err := doJSONWithFallback(ctx, "GET",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/jobs", url.PathEscape(owner), url.PathEscape(repo)),
+		},
+		query, nil, &result,
+	)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list action jobs err: %v", err))
+	}
+	return to.TextResult(result)
+}
+
+func ListRepoActionRunJobsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListRepoActionRunJobsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	runID, ok := req.GetArguments()["run_id"].(float64)
+	if !ok || runID <= 0 {
+		return to.ErrorResult(fmt.Errorf("run_id is required"))
+	}
+	page, _ := req.GetArguments()["page"].(float64)
+	if page <= 0 {
+		page = 1
+	}
+	pageSize, _ := req.GetArguments()["pageSize"].(float64)
+	if pageSize <= 0 {
+		pageSize = 50
+	}
+
+	query := url.Values{}
+	query.Set("page", fmt.Sprintf("%d", int(page)))
+	query.Set("limit", fmt.Sprintf("%d", int(pageSize)))
+
+	var result any
+	_, _, err := doJSONWithFallback(ctx, "GET",
+		[]string{
+			fmt.Sprintf("repos/%s/%s/actions/runs/%d/jobs", url.PathEscape(owner), url.PathEscape(repo), int64(runID)),
+		},
+		query, nil, &result,
+	)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list action run jobs err: %v", err))
+	}
+	return to.TextResult(result)
+}

operation/actions/secrets.go

@@ -0,0 +1,292 @@
+package actions
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"time"
+
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/log"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+
+	gitea_sdk "code.gitea.io/sdk/gitea"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+const (
+	ListRepoActionSecretsToolName  = "list_repo_action_secrets"
+	UpsertRepoActionSecretToolName = "upsert_repo_action_secret"
+	DeleteRepoActionSecretToolName = "delete_repo_action_secret"
+	ListOrgActionSecretsToolName   = "list_org_action_secrets"
+	UpsertOrgActionSecretToolName  = "upsert_org_action_secret"
+	DeleteOrgActionSecretToolName  = "delete_org_action_secret"
+)
+
+type secretMeta struct {
+	Name        string    `json:"name"`
+	Description string    `json:"description,omitempty"`
+	CreatedAt   time.Time `json:"created_at,omitempty"`
+}
+
+var (
+	ListRepoActionSecretsTool = mcp.NewTool(
+		ListRepoActionSecretsToolName,
+		mcp.WithDescription("List repository Actions secrets (metadata only; secret values are never returned)"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100), mcp.Min(1)),
+	)
+
+	UpsertRepoActionSecretTool = mcp.NewTool(
+		UpsertRepoActionSecretToolName,
+		mcp.WithDescription("Create or update (upsert) a repository Actions secret"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("secret name")),
+		mcp.WithString("data", mcp.Required(), mcp.Description("secret value")),
+		mcp.WithString("description", mcp.Description("secret description")),
+	)
+
+	DeleteRepoActionSecretTool = mcp.NewTool(
+		DeleteRepoActionSecretToolName,
+		mcp.WithDescription("Delete a repository Actions secret"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("secretName", mcp.Required(), mcp.Description("secret name")),
+	)
+
+	ListOrgActionSecretsTool = mcp.NewTool(
+		ListOrgActionSecretsToolName,
+		mcp.WithDescription("List organization Actions secrets (metadata only; secret values are never returned)"),
+		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100), mcp.Min(1)),
+	)
+
+	UpsertOrgActionSecretTool = mcp.NewTool(
+		UpsertOrgActionSecretToolName,
+		mcp.WithDescription("Create or update (upsert) an organization Actions secret"),
+		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("secret name")),
+		mcp.WithString("data", mcp.Required(), mcp.Description("secret value")),
+		mcp.WithString("description", mcp.Description("secret description")),
+	)
+
+	DeleteOrgActionSecretTool = mcp.NewTool(
+		DeleteOrgActionSecretToolName,
+		mcp.WithDescription("Delete an organization Actions secret"),
+		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+		mcp.WithString("secretName", mcp.Required(), mcp.Description("secret name")),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionSecretsTool, Handler: ListRepoActionSecretsFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: UpsertRepoActionSecretTool, Handler: UpsertRepoActionSecretFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: DeleteRepoActionSecretTool, Handler: DeleteRepoActionSecretFn})
+
+	Tool.RegisterRead(server.ServerTool{Tool: ListOrgActionSecretsTool, Handler: ListOrgActionSecretsFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: UpsertOrgActionSecretTool, Handler: UpsertOrgActionSecretFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: DeleteOrgActionSecretTool, Handler: DeleteOrgActionSecretFn})
+}
+
+func ListRepoActionSecretsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListRepoActionSecretsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	page, _ := req.GetArguments()["page"].(float64)
+	if page <= 0 {
+		page = 1
+	}
+	pageSize, _ := req.GetArguments()["pageSize"].(float64)
+	if pageSize <= 0 {
+		pageSize = 100
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+
+	secrets, _, err := client.ListRepoActionSecret(owner, repo, gitea_sdk.ListRepoActionSecretOption{
+		ListOptions: gitea_sdk.ListOptions{Page: int(page), PageSize: int(pageSize)},
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list repo action secrets err: %v", err))
+	}
+
+	metas := make([]secretMeta, 0, len(secrets))
+	for _, s := range secrets {
+		if s == nil {
+			continue
+		}
+		metas = append(metas, secretMeta{
+			Name:        s.Name,
+			Description: s.Description,
+			CreatedAt:   s.Created,
+		})
+	}
+	return to.TextResult(metas)
+}
+
+func UpsertRepoActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called UpsertRepoActionSecretFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+	data, ok := req.GetArguments()["data"].(string)
+	if !ok || data == "" {
+		return to.ErrorResult(fmt.Errorf("data is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.CreateRepoActionSecret(owner, repo, gitea_sdk.CreateSecretOption{
+		Name:        name,
+		Data:        data,
+		Description: description,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("upsert repo action secret err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "secret upserted", "status": resp.StatusCode})
+}
+
+func DeleteRepoActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DeleteRepoActionSecretFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	secretName, ok := req.GetArguments()["secretName"].(string)
+	if !ok || secretName == "" {
+		return to.ErrorResult(fmt.Errorf("secretName is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.DeleteRepoActionSecret(owner, repo, secretName)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete repo action secret err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "secret deleted", "status": resp.StatusCode})
+}
+
+func ListOrgActionSecretsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListOrgActionSecretsFn")
+	org, ok := req.GetArguments()["org"].(string)
+	if !ok || org == "" {
+		return to.ErrorResult(fmt.Errorf("org is required"))
+	}
+	page, _ := req.GetArguments()["page"].(float64)
+	if page <= 0 {
+		page = 1
+	}
+	pageSize, _ := req.GetArguments()["pageSize"].(float64)
+	if pageSize <= 0 {
+		pageSize = 100
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+
+	secrets, _, err := client.ListOrgActionSecret(org, gitea_sdk.ListOrgActionSecretOption{
+		ListOptions: gitea_sdk.ListOptions{Page: int(page), PageSize: int(pageSize)},
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list org action secrets err: %v", err))
+	}
+
+	metas := make([]secretMeta, 0, len(secrets))
+	for _, s := range secrets {
+		if s == nil {
+			continue
+		}
+		metas = append(metas, secretMeta{
+			Name:        s.Name,
+			Description: s.Description,
+			CreatedAt:   s.Created,
+		})
+	}
+	return to.TextResult(metas)
+}
+
+func UpsertOrgActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called UpsertOrgActionSecretFn")
+	org, ok := req.GetArguments()["org"].(string)
+	if !ok || org == "" {
+		return to.ErrorResult(fmt.Errorf("org is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+	data, ok := req.GetArguments()["data"].(string)
+	if !ok || data == "" {
+		return to.ErrorResult(fmt.Errorf("data is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.CreateOrgActionSecret(org, gitea_sdk.CreateSecretOption{
+		Name:        name,
+		Data:        data,
+		Description: description,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("upsert org action secret err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "secret upserted", "status": resp.StatusCode})
+}
+
+func DeleteOrgActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DeleteOrgActionSecretFn")
+	org, ok := req.GetArguments()["org"].(string)
+	if !ok || org == "" {
+		return to.ErrorResult(fmt.Errorf("org is required"))
+	}
+	secretName, ok := req.GetArguments()["secretName"].(string)
+	if !ok || secretName == "" {
+		return to.ErrorResult(fmt.Errorf("secretName is required"))
+	}
+
+	escapedOrg := url.PathEscape(org)
+	escapedSecret := url.PathEscape(secretName)
+	_, err := gitea.DoJSON(ctx, "DELETE", fmt.Sprintf("orgs/%s/actions/secrets/%s", escapedOrg, escapedSecret), nil, nil, nil)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete org action secret err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "secret deleted"})
+}

operation/actions/variables.go

@@ -0,0 +1,402 @@
+package actions
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/log"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+
+	gitea_sdk "code.gitea.io/sdk/gitea"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+const (
+	ListRepoActionVariablesToolName  = "list_repo_action_variables"
+	GetRepoActionVariableToolName    = "get_repo_action_variable"
+	CreateRepoActionVariableToolName = "create_repo_action_variable"
+	UpdateRepoActionVariableToolName = "update_repo_action_variable"
+	DeleteRepoActionVariableToolName = "delete_repo_action_variable"
+
+	ListOrgActionVariablesToolName   = "list_org_action_variables"
+	GetOrgActionVariableToolName     = "get_org_action_variable"
+	CreateOrgActionVariableToolName  = "create_org_action_variable"
+	UpdateOrgActionVariableToolName  = "update_org_action_variable"
+	DeleteOrgActionVariableToolName  = "delete_org_action_variable"
+)
+
+var (
+	ListRepoActionVariablesTool = mcp.NewTool(
+		ListRepoActionVariablesToolName,
+		mcp.WithDescription("List repository Actions variables"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100), mcp.Min(1)),
+	)
+
+	GetRepoActionVariableTool = mcp.NewTool(
+		GetRepoActionVariableToolName,
+		mcp.WithDescription("Get a repository Actions variable by name"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
+	)
+
+	CreateRepoActionVariableTool = mcp.NewTool(
+		CreateRepoActionVariableToolName,
+		mcp.WithDescription("Create a repository Actions variable"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
+		mcp.WithString("value", mcp.Required(), mcp.Description("variable value")),
+	)
+
+	UpdateRepoActionVariableTool = mcp.NewTool(
+		UpdateRepoActionVariableToolName,
+		mcp.WithDescription("Update a repository Actions variable"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
+		mcp.WithString("value", mcp.Required(), mcp.Description("new variable value")),
+	)
+
+	DeleteRepoActionVariableTool = mcp.NewTool(
+		DeleteRepoActionVariableToolName,
+		mcp.WithDescription("Delete a repository Actions variable"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
+	)
+
+	ListOrgActionVariablesTool = mcp.NewTool(
+		ListOrgActionVariablesToolName,
+		mcp.WithDescription("List organization Actions variables"),
+		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100), mcp.Min(1)),
+	)
+
+	GetOrgActionVariableTool = mcp.NewTool(
+		GetOrgActionVariableToolName,
+		mcp.WithDescription("Get an organization Actions variable by name"),
+		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
+	)
+
+	CreateOrgActionVariableTool = mcp.NewTool(
+		CreateOrgActionVariableToolName,
+		mcp.WithDescription("Create an organization Actions variable"),
+		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
+		mcp.WithString("value", mcp.Required(), mcp.Description("variable value")),
+		mcp.WithString("description", mcp.Description("variable description")),
+	)
+
+	UpdateOrgActionVariableTool = mcp.NewTool(
+		UpdateOrgActionVariableToolName,
+		mcp.WithDescription("Update an organization Actions variable"),
+		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
+		mcp.WithString("value", mcp.Required(), mcp.Description("new variable value")),
+		mcp.WithString("description", mcp.Description("new variable description")),
+	)
+
+	DeleteOrgActionVariableTool = mcp.NewTool(
+		DeleteOrgActionVariableToolName,
+		mcp.WithDescription("Delete an organization Actions variable"),
+		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionVariablesTool, Handler: ListRepoActionVariablesFn})
+	Tool.RegisterRead(server.ServerTool{Tool: GetRepoActionVariableTool, Handler: GetRepoActionVariableFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: CreateRepoActionVariableTool, Handler: CreateRepoActionVariableFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: UpdateRepoActionVariableTool, Handler: UpdateRepoActionVariableFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: DeleteRepoActionVariableTool, Handler: DeleteRepoActionVariableFn})
+
+	Tool.RegisterRead(server.ServerTool{Tool: ListOrgActionVariablesTool, Handler: ListOrgActionVariablesFn})
+	Tool.RegisterRead(server.ServerTool{Tool: GetOrgActionVariableTool, Handler: GetOrgActionVariableFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: CreateOrgActionVariableTool, Handler: CreateOrgActionVariableFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: UpdateOrgActionVariableTool, Handler: UpdateOrgActionVariableFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: DeleteOrgActionVariableTool, Handler: DeleteOrgActionVariableFn})
+}
+
+func ListRepoActionVariablesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListRepoActionVariablesFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	page, _ := req.GetArguments()["page"].(float64)
+	if page <= 0 {
+		page = 1
+	}
+	pageSize, _ := req.GetArguments()["pageSize"].(float64)
+	if pageSize <= 0 {
+		pageSize = 100
+	}
+
+	query := url.Values{}
+	query.Set("page", fmt.Sprintf("%d", int(page)))
+	query.Set("limit", fmt.Sprintf("%d", int(pageSize)))
+
+	var result any
+	_, err := gitea.DoJSON(ctx, "GET", fmt.Sprintf("repos/%s/%s/actions/variables", url.PathEscape(owner), url.PathEscape(repo)), query, nil, &result)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list repo action variables err: %v", err))
+	}
+	return to.TextResult(result)
+}
+
+func GetRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetRepoActionVariableFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	variable, _, err := client.GetRepoActionVariable(owner, repo, name)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get repo action variable err: %v", err))
+	}
+	return to.TextResult(variable)
+}
+
+func CreateRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called CreateRepoActionVariableFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+	value, ok := req.GetArguments()["value"].(string)
+	if !ok || value == "" {
+		return to.ErrorResult(fmt.Errorf("value is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.CreateRepoActionVariable(owner, repo, name, value)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create repo action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable created", "status": resp.StatusCode})
+}
+
+func UpdateRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called UpdateRepoActionVariableFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+	value, ok := req.GetArguments()["value"].(string)
+	if !ok || value == "" {
+		return to.ErrorResult(fmt.Errorf("value is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.UpdateRepoActionVariable(owner, repo, name, value)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("update repo action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable updated", "status": resp.StatusCode})
+}
+
+func DeleteRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DeleteRepoActionVariableFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok || owner == "" {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok || repo == "" {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.DeleteRepoActionVariable(owner, repo, name)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete repo action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable deleted", "status": resp.StatusCode})
+}
+
+func ListOrgActionVariablesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListOrgActionVariablesFn")
+	org, ok := req.GetArguments()["org"].(string)
+	if !ok || org == "" {
+		return to.ErrorResult(fmt.Errorf("org is required"))
+	}
+	page, _ := req.GetArguments()["page"].(float64)
+	if page <= 0 {
+		page = 1
+	}
+	pageSize, _ := req.GetArguments()["pageSize"].(float64)
+	if pageSize <= 0 {
+		pageSize = 100
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	variables, _, err := client.ListOrgActionVariable(org, gitea_sdk.ListOrgActionVariableOption{
+		ListOptions: gitea_sdk.ListOptions{Page: int(page), PageSize: int(pageSize)},
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list org action variables err: %v", err))
+	}
+	return to.TextResult(variables)
+}
+
+func GetOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetOrgActionVariableFn")
+	org, ok := req.GetArguments()["org"].(string)
+	if !ok || org == "" {
+		return to.ErrorResult(fmt.Errorf("org is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	variable, _, err := client.GetOrgActionVariable(org, name)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get org action variable err: %v", err))
+	}
+	return to.TextResult(variable)
+}
+
+func CreateOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called CreateOrgActionVariableFn")
+	org, ok := req.GetArguments()["org"].(string)
+	if !ok || org == "" {
+		return to.ErrorResult(fmt.Errorf("org is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+	value, ok := req.GetArguments()["value"].(string)
+	if !ok || value == "" {
+		return to.ErrorResult(fmt.Errorf("value is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.CreateOrgActionVariable(org, gitea_sdk.CreateOrgActionVariableOption{
+		Name:        name,
+		Value:       value,
+		Description: description,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create org action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable created", "status": resp.StatusCode})
+}
+
+func UpdateOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called UpdateOrgActionVariableFn")
+	org, ok := req.GetArguments()["org"].(string)
+	if !ok || org == "" {
+		return to.ErrorResult(fmt.Errorf("org is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+	value, ok := req.GetArguments()["value"].(string)
+	if !ok || value == "" {
+		return to.ErrorResult(fmt.Errorf("value is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.UpdateOrgActionVariable(org, name, gitea_sdk.UpdateOrgActionVariableOption{
+		Value:       value,
+		Description: description,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("update org action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable updated", "status": resp.StatusCode})
+}
+
+func DeleteOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DeleteOrgActionVariableFn")
+	org, ok := req.GetArguments()["org"].(string)
+	if !ok || org == "" {
+		return to.ErrorResult(fmt.Errorf("org is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok || name == "" {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+
+	_, err := gitea.DoJSON(ctx, "DELETE", fmt.Sprintf("orgs/%s/actions/variables/%s", url.PathEscape(org), url.PathEscape(name)), nil, nil, nil)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete org action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable deleted"})
+}
+
+

operation/issue/issue.go

@@ -140,7 +140,11 @@ func GetIssueByIndexFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallT
 	if !ok {
 		return to.ErrorResult(fmt.Errorf("index is required"))
 	}
-	issue, _, err := gitea.Client().GetIssue(owner, repo, int64(index))
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issue, _, err := client.GetIssue(owner, repo, int64(index))
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get %v/%v/issue/%v err: %v", owner, repo, int64(index), err))
 	}
@@ -177,7 +181,11 @@ func ListRepoIssuesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallTo
 			PageSize: int(pageSize),
 		},
 	}
-	issues, _, err := gitea.Client().ListRepoIssues(owner, repo, opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issues, _, err := client.ListRepoIssues(owner, repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get %v/%v/issues err: %v", owner, repo, err))
 	}
@@ -202,7 +210,11 @@ func CreateIssueFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolR
 	if !ok {
 		return to.ErrorResult(fmt.Errorf("body is required"))
 	}
-	issue, _, err := gitea.Client().CreateIssue(owner, repo, gitea_sdk.CreateIssueOption{
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issue, _, err := client.CreateIssue(owner, repo, gitea_sdk.CreateIssueOption{
 		Title: title,
 		Body:  body,
 	})
@@ -234,7 +246,11 @@ func CreateIssueCommentFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Ca
 	opt := gitea_sdk.CreateIssueCommentOption{
 		Body: body,
 	}
-	issueComment, _, err := gitea.Client().CreateIssueComment(owner, repo, int64(index), opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issueComment, _, err := client.CreateIssueComment(owner, repo, int64(index), opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("create %v/%v/issue/%v/comment err: %v", owner, repo, int64(index), err))
 	}
@@ -267,10 +283,17 @@ func EditIssueFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRes
 	if ok {
 		opt.Body = ptr.To(body)
 	}
-	assignees, ok := req.GetArguments()["assignees"].([]string)
+	var assignees []string
-	if ok {
+	if assigneesArg, exists := req.GetArguments()["assignees"]; exists {
-		opt.Assignees = assignees
+		if assigneesSlice, ok := assigneesArg.([]interface{}); ok {
+			for _, assignee := range assigneesSlice {
+				if assigneeStr, ok := assignee.(string); ok {
+					assignees = append(assignees, assigneeStr)
 				}
+			}
+		}
+	}
+	opt.Assignees = assignees
 	milestone, ok := req.GetArguments()["milestone"].(float64)
 	if ok {
 		opt.Milestone = ptr.To(int64(milestone))
@@ -280,7 +303,11 @@ func EditIssueFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRes
 		opt.State = ptr.To(gitea_sdk.StateType(state))
 	}
 
-	issue, _, err := gitea.Client().EditIssue(owner, repo, int64(index), opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issue, _, err := client.EditIssue(owner, repo, int64(index), opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("edit %v/%v/issue/%v err: %v", owner, repo, int64(index), err))
 	}
@@ -309,7 +336,11 @@ func EditIssueCommentFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Call
 	opt := gitea_sdk.EditIssueCommentOption{
 		Body: body,
 	}
-	issueComment, _, err := gitea.Client().EditIssueComment(owner, repo, int64(commentID), opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issueComment, _, err := client.EditIssueComment(owner, repo, int64(commentID), opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("edit %v/%v/issues/comments/%v err: %v", owner, repo, int64(commentID), err))
 	}
@@ -332,7 +363,11 @@ func GetIssueCommentsByIndexFn(ctx context.Context, req mcp.CallToolRequest) (*m
 		return to.ErrorResult(fmt.Errorf("index is required"))
 	}
 	opt := gitea_sdk.ListIssueCommentOptions{}
-	issue, _, err := gitea.Client().ListIssueComments(owner, repo, int64(index), opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issue, _, err := client.ListIssueComments(owner, repo, int64(index), opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get %v/%v/issues/%v/comments err: %v", owner, repo, int64(index), err))
 	}

operation/label/label.go

@@ -0,0 +1,636 @@
+package label
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/log"
+	"gitea.com/gitea/gitea-mcp/pkg/ptr"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+	"gitea.com/gitea/gitea-mcp/pkg/tool"
+
+	gitea_sdk "code.gitea.io/sdk/gitea"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+var Tool = tool.New()
+
+const (
+	ListRepoLabelsToolName     = "list_repo_labels"
+	GetRepoLabelToolName       = "get_repo_label"
+	CreateRepoLabelToolName    = "create_repo_label"
+	EditRepoLabelToolName      = "edit_repo_label"
+	DeleteRepoLabelToolName    = "delete_repo_label"
+	AddIssueLabelsToolName     = "add_issue_labels"
+	ReplaceIssueLabelsToolName = "replace_issue_labels"
+	ClearIssueLabelsToolName   = "clear_issue_labels"
+	RemoveIssueLabelToolName   = "remove_issue_label"
+    ListOrgLabelsToolName      = "list_org_labels"
+    CreateOrgLabelToolName     = "create_org_label"
+    EditOrgLabelToolName       = "edit_org_label"
+    DeleteOrgLabelToolName     = "delete_org_label"
+)
+
+var (
+	ListRepoLabelsTool = mcp.NewTool(
+		ListRepoLabelsToolName,
+		mcp.WithDescription("Lists all labels for a given repository"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100)),
+	)
+
+	GetRepoLabelTool = mcp.NewTool(
+		GetRepoLabelToolName,
+		mcp.WithDescription("Gets a single label by its ID for a repository"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("id", mcp.Required(), mcp.Description("label ID")),
+	)
+
+	CreateRepoLabelTool = mcp.NewTool(
+		CreateRepoLabelToolName,
+		mcp.WithDescription("Creates a new label for a repository"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("name", mcp.Required(), mcp.Description("label name")),
+		mcp.WithString("color", mcp.Required(), mcp.Description("label color (hex code, e.g., #RRGGBB)")),
+		mcp.WithString("description", mcp.Description("label description")),
+	)
+
+	EditRepoLabelTool = mcp.NewTool(
+		EditRepoLabelToolName,
+		mcp.WithDescription("Edits an existing label in a repository"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("id", mcp.Required(), mcp.Description("label ID")),
+		mcp.WithString("name", mcp.Description("new label name")),
+		mcp.WithString("color", mcp.Description("new label color (hex code, e.g., #RRGGBB)")),
+		mcp.WithString("description", mcp.Description("new label description")),
+	)
+
+	DeleteRepoLabelTool = mcp.NewTool(
+		DeleteRepoLabelToolName,
+		mcp.WithDescription("Deletes a label from a repository"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("id", mcp.Required(), mcp.Description("label ID")),
+	)
+
+	AddIssueLabelsTool = mcp.NewTool(
+		AddIssueLabelsToolName,
+		mcp.WithDescription("Adds one or more labels to an issue"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("index", mcp.Required(), mcp.Description("issue index")),
+		mcp.WithArray("labels", mcp.Required(), mcp.Description("array of label IDs to add"), mcp.Items(map[string]interface{}{"type": "number"})),
+	)
+
+	ReplaceIssueLabelsTool = mcp.NewTool(
+		ReplaceIssueLabelsToolName,
+		mcp.WithDescription("Replaces all labels on an issue"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("index", mcp.Required(), mcp.Description("issue index")),
+		mcp.WithArray("labels", mcp.Required(), mcp.Description("array of label IDs to replace with"), mcp.Items(map[string]interface{}{"type": "number"})),
+	)
+
+	ClearIssueLabelsTool = mcp.NewTool(
+		ClearIssueLabelsToolName,
+		mcp.WithDescription("Removes all labels from an issue"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("index", mcp.Required(), mcp.Description("issue index")),
+	)
+
+	RemoveIssueLabelTool = mcp.NewTool(
+		RemoveIssueLabelToolName,
+		mcp.WithDescription("Removes a single label from an issue"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("index", mcp.Required(), mcp.Description("issue index")),
+		mcp.WithNumber("label_id", mcp.Required(), mcp.Description("label ID to remove")),
+	)
+
+    ListOrgLabelsTool = mcp.NewTool(
+        ListOrgLabelsToolName,
+        mcp.WithDescription("Lists labels defined at organization level"),
+        mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+        mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1)),
+        mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100)),
+    )
+
+    CreateOrgLabelTool = mcp.NewTool(
+        CreateOrgLabelToolName,
+        mcp.WithDescription("Creates a new label for an organization"),
+        mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+        mcp.WithString("name", mcp.Required(), mcp.Description("label name")),
+        mcp.WithString("color", mcp.Required(), mcp.Description("label color (hex code, e.g., #RRGGBB)")),
+        mcp.WithString("description", mcp.Description("label description")),
+        mcp.WithBoolean("exclusive", mcp.Description("whether the label is exclusive"), mcp.DefaultBool(false)),
+    )
+
+    EditOrgLabelTool = mcp.NewTool(
+        EditOrgLabelToolName,
+        mcp.WithDescription("Edits an existing organization label"),
+        mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+        mcp.WithNumber("id", mcp.Required(), mcp.Description("label ID")),
+        mcp.WithString("name", mcp.Description("new label name")),
+        mcp.WithString("color", mcp.Description("new label color (hex code, e.g., #RRGGBB)")),
+        mcp.WithString("description", mcp.Description("new label description")),
+        mcp.WithBoolean("exclusive", mcp.Description("whether the label is exclusive")),
+    )
+
+    DeleteOrgLabelTool = mcp.NewTool(
+        DeleteOrgLabelToolName,
+        mcp.WithDescription("Deletes an organization label by ID"),
+        mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
+        mcp.WithNumber("id", mcp.Required(), mcp.Description("label ID")),
+    )
+
+)
+
+func init() {
+	Tool.RegisterRead(server.ServerTool{
+		Tool:    ListRepoLabelsTool,
+		Handler: ListRepoLabelsFn,
+	})
+	Tool.RegisterRead(server.ServerTool{
+		Tool:    GetRepoLabelTool,
+		Handler: GetRepoLabelFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    CreateRepoLabelTool,
+		Handler: CreateRepoLabelFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    EditRepoLabelTool,
+		Handler: EditRepoLabelFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    DeleteRepoLabelTool,
+		Handler: DeleteRepoLabelFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    AddIssueLabelsTool,
+		Handler: AddIssueLabelsFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    ReplaceIssueLabelsTool,
+		Handler: ReplaceIssueLabelsFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    ClearIssueLabelsTool,
+		Handler: ClearIssueLabelsFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    RemoveIssueLabelTool,
+		Handler: RemoveIssueLabelFn,
+	})
+    Tool.RegisterRead(server.ServerTool{
+        Tool:    ListOrgLabelsTool,
+        Handler: ListOrgLabelsFn,
+    })
+    Tool.RegisterWrite(server.ServerTool{
+        Tool:    CreateOrgLabelTool,
+        Handler: CreateOrgLabelFn,
+    })
+    Tool.RegisterWrite(server.ServerTool{
+        Tool:    EditOrgLabelTool,
+        Handler: EditOrgLabelFn,
+    })
+    Tool.RegisterWrite(server.ServerTool{
+        Tool:    DeleteOrgLabelTool,
+        Handler: DeleteOrgLabelFn,
+    })
+}
+
+func ListRepoLabelsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListRepoLabelsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	page, ok := req.GetArguments()["page"].(float64)
+	if !ok {
+		page = 1
+	}
+	pageSize, ok := req.GetArguments()["pageSize"].(float64)
+	if !ok {
+		pageSize = 100
+	}
+
+	opt := gitea_sdk.ListLabelsOptions{
+		ListOptions: gitea_sdk.ListOptions{
+			Page:     int(page),
+			PageSize: int(pageSize),
+		},
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	labels, _, err := client.ListRepoLabels(owner, repo, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list %v/%v/labels err: %v", owner, repo, err))
+	}
+	return to.TextResult(labels)
+}
+
+func GetRepoLabelFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetRepoLabelFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	id, ok := req.GetArguments()["id"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("label ID is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	label, _, err := client.GetRepoLabel(owner, repo, int64(id))
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get %v/%v/label/%v err: %v", owner, repo, int64(id), err))
+	}
+	return to.TextResult(label)
+}
+
+func CreateRepoLabelFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called CreateRepoLabelFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("name is required"))
+	}
+	color, ok := req.GetArguments()["color"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("color is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string) // Optional
+
+	opt := gitea_sdk.CreateLabelOption{
+		Name:        name,
+		Color:       color,
+		Description: description,
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	label, _, err := client.CreateLabel(owner, repo, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create %v/%v/label err: %v", owner, repo, err))
+	}
+	return to.TextResult(label)
+}
+
+func EditRepoLabelFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called EditRepoLabelFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	id, ok := req.GetArguments()["id"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("label ID is required"))
+	}
+
+	opt := gitea_sdk.EditLabelOption{}
+	if name, ok := req.GetArguments()["name"].(string); ok {
+		opt.Name = ptr.To(name)
+	}
+	if color, ok := req.GetArguments()["color"].(string); ok {
+		opt.Color = ptr.To(color)
+	}
+	if description, ok := req.GetArguments()["description"].(string); ok {
+		opt.Description = ptr.To(description)
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	label, _, err := client.EditLabel(owner, repo, int64(id), opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("edit %v/%v/label/%v err: %v", owner, repo, int64(id), err))
+	}
+	return to.TextResult(label)
+}
+
+func DeleteRepoLabelFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DeleteRepoLabelFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	id, ok := req.GetArguments()["id"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("label ID is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.DeleteLabel(owner, repo, int64(id))
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete %v/%v/label/%v err: %v", owner, repo, int64(id), err))
+	}
+	return to.TextResult("Label deleted successfully")
+}
+
+func AddIssueLabelsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called AddIssueLabelsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	index, ok := req.GetArguments()["index"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("issue index is required"))
+	}
+	labelsRaw, ok := req.GetArguments()["labels"].([]interface{})
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("labels (array of IDs) is required"))
+	}
+	var labels []int64
+	for _, l := range labelsRaw {
+		if labelID, ok := l.(float64); ok {
+			labels = append(labels, int64(labelID))
+		} else {
+			return to.ErrorResult(fmt.Errorf("invalid label ID in labels array"))
+		}
+	}
+
+	opt := gitea_sdk.IssueLabelsOption{
+		Labels: labels,
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issueLabels, _, err := client.AddIssueLabels(owner, repo, int64(index), opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("add labels to %v/%v/issue/%v err: %v", owner, repo, int64(index), err))
+	}
+	return to.TextResult(issueLabels)
+}
+
+func ReplaceIssueLabelsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ReplaceIssueLabelsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	index, ok := req.GetArguments()["index"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("issue index is required"))
+	}
+	labelsRaw, ok := req.GetArguments()["labels"].([]interface{})
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("labels (array of IDs) is required"))
+	}
+	var labels []int64
+	for _, l := range labelsRaw {
+		if labelID, ok := l.(float64); ok {
+			labels = append(labels, int64(labelID))
+		} else {
+			return to.ErrorResult(fmt.Errorf("invalid label ID in labels array"))
+		}
+	}
+
+	opt := gitea_sdk.IssueLabelsOption{
+		Labels: labels,
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issueLabels, _, err := client.ReplaceIssueLabels(owner, repo, int64(index), opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("replace labels on %v/%v/issue/%v err: %v", owner, repo, int64(index), err))
+	}
+	return to.TextResult(issueLabels)
+}
+
+func ClearIssueLabelsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ClearIssueLabelsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	index, ok := req.GetArguments()["index"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("issue index is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.ClearIssueLabels(owner, repo, int64(index))
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("clear labels on %v/%v/issue/%v err: %v", owner, repo, int64(index), err))
+	}
+	return to.TextResult("Labels cleared successfully")
+}
+
+func RemoveIssueLabelFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called RemoveIssueLabelFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	index, ok := req.GetArguments()["index"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("issue index is required"))
+	}
+	labelID, ok := req.GetArguments()["label_id"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("label ID is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.DeleteIssueLabel(owner, repo, int64(index), int64(labelID))
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("remove label %v from %v/%v/issue/%v err: %v", int64(labelID), owner, repo, int64(index), err))
+	}
+	return to.TextResult("Label removed successfully")
+}
+
+func ListOrgLabelsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+    log.Debugf("Called ListOrgLabelsFn")
+    org, ok := req.GetArguments()["org"].(string)
+    if !ok {
+        return to.ErrorResult(fmt.Errorf("org is required"))
+    }
+    page, ok := req.GetArguments()["page"].(float64)
+    if !ok {
+        page = 1
+    }
+    pageSize, ok := req.GetArguments()["pageSize"].(float64)
+    if !ok {
+        pageSize = 100
+    }
+
+    opt := gitea_sdk.ListOrgLabelsOptions{
+        ListOptions: gitea_sdk.ListOptions{
+            Page:     int(page),
+            PageSize: int(pageSize),
+        },
+    }
+    client, err := gitea.ClientFromContext(ctx)
+    if err != nil {
+        return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+    }
+    labels, _, err := client.ListOrgLabels(org, opt)
+    if err != nil {
+        return to.ErrorResult(fmt.Errorf("list %v/labels err: %v", org, err))
+    }
+    return to.TextResult(labels)
+}
+
+func CreateOrgLabelFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+    log.Debugf("Called CreateOrgLabelFn")
+    org, ok := req.GetArguments()["org"].(string)
+    if !ok {
+        return to.ErrorResult(fmt.Errorf("org is required"))
+    }
+    name, ok := req.GetArguments()["name"].(string)
+    if !ok {
+        return to.ErrorResult(fmt.Errorf("name is required"))
+    }
+    color, ok := req.GetArguments()["color"].(string)
+    if !ok {
+        return to.ErrorResult(fmt.Errorf("color is required"))
+    }
+    description, _ := req.GetArguments()["description"].(string)
+    exclusive, _ := req.GetArguments()["exclusive"].(bool)
+
+    opt := gitea_sdk.CreateOrgLabelOption{
+        Name:        name,
+        Color:       color,
+        Description: description,
+        Exclusive:   exclusive,
+    }
+
+    client, err := gitea.ClientFromContext(ctx)
+    if err != nil {
+        return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+    }
+    label, _, err := client.CreateOrgLabel(org, opt)
+    if err != nil {
+        return to.ErrorResult(fmt.Errorf("create %v/labels err: %v", org, err))
+    }
+    return to.TextResult(label)
+}
+
+func EditOrgLabelFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+    log.Debugf("Called EditOrgLabelFn")
+    org, ok := req.GetArguments()["org"].(string)
+    if !ok {
+        return to.ErrorResult(fmt.Errorf("org is required"))
+    }
+    id, ok := req.GetArguments()["id"].(float64)
+    if !ok {
+        return to.ErrorResult(fmt.Errorf("label ID is required"))
+    }
+
+    opt := gitea_sdk.EditOrgLabelOption{}
+    if name, ok := req.GetArguments()["name"].(string); ok {
+        opt.Name = ptr.To(name)
+    }
+    if color, ok := req.GetArguments()["color"].(string); ok {
+        opt.Color = ptr.To(color)
+    }
+    if description, ok := req.GetArguments()["description"].(string); ok {
+        opt.Description = ptr.To(description)
+    }
+    if exclusive, ok := req.GetArguments()["exclusive"].(bool); ok {
+        opt.Exclusive = ptr.To(exclusive)
+    }
+
+    client, err := gitea.ClientFromContext(ctx)
+    if err != nil {
+        return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+    }
+    label, _, err := client.EditOrgLabel(org, int64(id), opt)
+    if err != nil {
+        return to.ErrorResult(fmt.Errorf("edit %v/labels/%v err: %v", org, int64(id), err))
+    }
+    return to.TextResult(label)
+}
+
+func DeleteOrgLabelFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+    log.Debugf("Called DeleteOrgLabelFn")
+    org, ok := req.GetArguments()["org"].(string)
+    if !ok {
+        return to.ErrorResult(fmt.Errorf("org is required"))
+    }
+    id, ok := req.GetArguments()["id"].(float64)
+    if !ok {
+        return to.ErrorResult(fmt.Errorf("label ID is required"))
+    }
+
+    client, err := gitea.ClientFromContext(ctx)
+    if err != nil {
+        return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+    }
+    _, err = client.DeleteOrgLabel(org, int64(id))
+    if err != nil {
+        return to.ErrorResult(fmt.Errorf("delete %v/labels/%v err: %v", org, int64(id), err))
+    }
+    return to.TextResult("Label deleted successfully")
+}

operation/milestone/milestone.go

@@ -0,0 +1,275 @@
+package milestone
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/log"
+	"gitea.com/gitea/gitea-mcp/pkg/ptr"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+	"gitea.com/gitea/gitea-mcp/pkg/tool"
+
+	gitea_sdk "code.gitea.io/sdk/gitea"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+var Tool = tool.New()
+
+const (
+	GetMilestoneToolName    = "get_milestone"
+	ListMilestonesToolName  = "list_milestones"
+	CreateMilestoneToolName = "create_milestone"
+	EditMilestoneToolName   = "edit_milestone"
+	DeleteMilestoneToolName = "delete_milestone"
+)
+
+var (
+	GetMilestoneTool = mcp.NewTool(
+		GetMilestoneToolName,
+		mcp.WithDescription("get milestone by id"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("id", mcp.Required(), mcp.Description("milestone id")),
+	)
+
+	ListMilestonesTool = mcp.NewTool(
+		ListMilestonesToolName,
+		mcp.WithDescription("List milestones"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("state", mcp.Description("milestone state"), mcp.DefaultString("all")),
+		mcp.WithString("name", mcp.Description("milestone name")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100)),
+	)
+
+	CreateMilestoneTool = mcp.NewTool(
+		CreateMilestoneToolName,
+		mcp.WithDescription("create milestone"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("title", mcp.Required(), mcp.Description("milestone title")),
+		mcp.WithString("description", mcp.Description("milestone description")),
+		mcp.WithString("due_on", mcp.Description("due date")),
+	)
+
+	EditMilestoneTool = mcp.NewTool(
+		EditMilestoneToolName,
+		mcp.WithDescription("edit milestone"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("id", mcp.Required(), mcp.Description("milestone id")),
+		mcp.WithString("title", mcp.Description("milestone title")),
+		mcp.WithString("description", mcp.Description("milestone description")),
+		mcp.WithString("due_on", mcp.Description("due date")),
+		mcp.WithString("state", mcp.Description("milestone state, one of open, closed")),
+	)
+
+	DeleteMilestoneTool = mcp.NewTool(
+		DeleteMilestoneToolName,
+		mcp.WithDescription("delete milestone"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("id", mcp.Required(), mcp.Description("milestone id")),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(server.ServerTool{
+		Tool:    GetMilestoneTool,
+		Handler: GetMilestoneFn,
+	})
+	Tool.RegisterRead(server.ServerTool{
+		Tool:    ListMilestonesTool,
+		Handler: ListMilestonesFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    CreateMilestoneTool,
+		Handler: CreateMilestoneFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    EditMilestoneTool,
+		Handler: EditMilestoneFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    DeleteMilestoneTool,
+		Handler: DeleteMilestoneFn,
+	})
+}
+
+func GetMilestoneFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetMilestoneFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	id, ok := req.GetArguments()["id"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("id is required"))
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	milestone, _, err := client.GetMilestone(owner, repo, int64(id))
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get %v/%v/milestone/%v err: %v", owner, repo, int64(id), err))
+	}
+
+	return to.TextResult(milestone)
+}
+
+func ListMilestonesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListMilestonesFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	state, ok := req.GetArguments()["state"].(string)
+	if !ok {
+		state = "all"
+	}
+	name, ok := req.GetArguments()["name"].(string)
+	if !ok {
+		name = ""
+	}
+	page, ok := req.GetArguments()["page"].(float64)
+	if !ok {
+		page = 1
+	}
+	pageSize, ok := req.GetArguments()["pageSize"].(float64)
+	if !ok {
+		pageSize = 100
+	}
+	opt := gitea_sdk.ListMilestoneOption{
+		State: gitea_sdk.StateType(state),
+		Name:  name,
+		ListOptions: gitea_sdk.ListOptions{
+			Page:     int(page),
+			PageSize: int(pageSize),
+		},
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	milestones, _, err := client.ListRepoMilestones(owner, repo, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get %v/%v/milestones err: %v", owner, repo, err))
+	}
+	return to.TextResult(milestones)
+}
+
+func CreateMilestoneFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called CreateMilestoneFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	title, ok := req.GetArguments()["title"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("title is required"))
+	}
+
+	opt := gitea_sdk.CreateMilestoneOption{
+		Title: title,
+	}
+
+	description, ok := req.GetArguments()["description"].(string)
+	if ok {
+		opt.Description = description
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	milestone, _, err := client.CreateMilestone(owner, repo, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create %v/%v/milestone err: %v", owner, repo, err))
+	}
+
+	return to.TextResult(milestone)
+}
+
+func EditMilestoneFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called EditMilestoneFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	id, ok := req.GetArguments()["id"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("id is required"))
+	}
+
+	opt := gitea_sdk.EditMilestoneOption{}
+
+	title, ok := req.GetArguments()["title"].(string)
+	if ok {
+		opt.Title = title
+	}
+	description, ok := req.GetArguments()["description"].(string)
+	if ok {
+		opt.Description = ptr.To(description)
+	}
+	state, ok := req.GetArguments()["state"].(string)
+	if ok {
+		opt.State = ptr.To(gitea_sdk.StateType(state))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	milestone, _, err := client.EditMilestone(owner, repo, int64(id), opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("edit %v/%v/milestone/%v err: %v", owner, repo, int64(id), err))
+	}
+
+	return to.TextResult(milestone)
+}
+
+func DeleteMilestoneFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DeleteMilestoneFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	id, ok := req.GetArguments()["id"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("id is required"))
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.DeleteMilestone(owner, repo, int64(id))
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete %v/%v/milestone/%v err: %v", owner, repo, int64(id), err))
+	}
+
+	return to.TextResult("Milestone deleted successfully")
+}

operation/operation.go

@@ -1,15 +1,26 @@
 package operation
 
 import (
+	"context"
 	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
 	"time"
 
 	"gitea.com/gitea/gitea-mcp/operation/issue"
+	"gitea.com/gitea/gitea-mcp/operation/label"
+	"gitea.com/gitea/gitea-mcp/operation/milestone"
+	"gitea.com/gitea/gitea-mcp/operation/actions"
 	"gitea.com/gitea/gitea-mcp/operation/pull"
 	"gitea.com/gitea/gitea-mcp/operation/repo"
 	"gitea.com/gitea/gitea-mcp/operation/search"
 	"gitea.com/gitea/gitea-mcp/operation/user"
 	"gitea.com/gitea/gitea-mcp/operation/version"
+	"gitea.com/gitea/gitea-mcp/operation/wiki"
+	mcpContext "gitea.com/gitea/gitea-mcp/pkg/context"
 	"gitea.com/gitea/gitea-mcp/pkg/flag"
 	"gitea.com/gitea/gitea-mcp/pkg/log"
 
@@ -22,12 +33,21 @@ func RegisterTool(s *server.MCPServer) {
 	// User Tool
 	s.AddTools(user.Tool.Tools()...)
 
+	// Actions Tool
+	s.AddTools(actions.Tool.Tools()...)
+
 	// Repo Tool
 	s.AddTools(repo.Tool.Tools()...)
 
 	// Issue Tool
 	s.AddTools(issue.Tool.Tools()...)
 
+	// Label Tool
+	s.AddTools(label.Tool.Tools()...)
+
+	// Milestone Tool
+	s.AddTools(milestone.Tool.Tools()...)
+
 	// Pull Tool
 	s.AddTools(pull.Tool.Tools()...)
 
@@ -37,9 +57,42 @@ func RegisterTool(s *server.MCPServer) {
 	// Version Tool
 	s.AddTools(version.Tool.Tools()...)
 
+	// Wiki Tool
+	s.AddTools(wiki.Tool.Tools()...)
+
 	s.DeleteTools("")
 }
 
+// parseBearerToken extracts the Bearer token from an Authorization header.
+// Returns the token and true if valid, empty string and false otherwise.
+func parseBearerToken(authHeader string) (string, bool) {
+	const bearerPrefix = "Bearer "
+	if len(authHeader) < len(bearerPrefix) || !strings.HasPrefix(authHeader, bearerPrefix) {
+		return "", false
+	}
+
+	token := strings.TrimSpace(authHeader[len(bearerPrefix):])
+	if token == "" {
+		return "", false
+	}
+
+	return token, true
+}
+
+func getContextWithToken(ctx context.Context, r *http.Request) context.Context {
+	authHeader := r.Header.Get("Authorization")
+	if authHeader == "" {
+		return ctx
+	}
+
+	token, ok := parseBearerToken(authHeader)
+	if !ok {
+		return ctx
+	}
+
+	return context.WithValue(ctx, mcpContext.TokenContextKey, token)
+}
+
 func Run() error {
 	mcpServer = newMCPServer(flag.Version)
 	RegisterTool(mcpServer)
@@ -50,26 +103,37 @@ func Run() error {
 		); err != nil {
 			return err
 		}
-	case "sse":
-		sseServer := server.NewSSEServer(
-			mcpServer,
-		)
-		log.Infof("Gitea MCP SSE server listening on :%d", flag.Port)
-		if err := sseServer.Start(fmt.Sprintf(":%d", flag.Port)); err != nil {
-			return err
-		}
 	case "http":
 		httpServer := server.NewStreamableHTTPServer(
 			mcpServer,
 			server.WithLogger(log.New()),
 			server.WithHeartbeatInterval(30*time.Second),
+			server.WithHTTPContextFunc(getContextWithToken),
 		)
 		log.Infof("Gitea MCP HTTP server listening on :%d", flag.Port)
+
+		// Graceful shutdown setup
+		sigCh := make(chan os.Signal, 1)
+		signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
+		shutdownDone := make(chan struct{})
+
+		go func() {
+			<-sigCh
+			log.Infof("Shutdown signal received, gracefully stopping HTTP server...")
+			shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+			defer cancel()
+			if err := httpServer.Shutdown(shutdownCtx); err != nil {
+				log.Errorf("HTTP server shutdown error: %v", err)
+			}
+			close(shutdownDone)
+		}()
+
 		if err := httpServer.Start(fmt.Sprintf(":%d", flag.Port)); err != nil {
 			return err
 		}
+		<-shutdownDone // Wait for shutdown to finish
 	default:
-		return fmt.Errorf("invalid transport type: %s. Must be 'stdio', 'sse' or 'http'", flag.Mode)
+		return fmt.Errorf("invalid transport type: %s. Must be 'stdio' or 'http'", flag.Mode)
 	}
 	return nil
 }

operation/operation_test.go

@@ -0,0 +1,81 @@
+package operation
+
+import (
+	"testing"
+)
+
+func TestParseBearerToken(t *testing.T) {
+	tests := []struct {
+		name      string
+		header    string
+		wantToken string
+		wantOK    bool
+	}{
+		{
+			name:      "valid token",
+			header:    "Bearer validtoken",
+			wantToken: "validtoken",
+			wantOK:    true,
+		},
+		{
+			name:      "token with spaces trimmed",
+			header:    "Bearer   spacedToken ",
+			wantToken: "spacedToken",
+			wantOK:    true,
+		},
+		{
+			name:      "lowercase bearer should fail",
+			header:    "bearer lowercase",
+			wantToken: "",
+			wantOK:    false,
+		},
+		{
+			name:      "bearer with no token",
+			header:    "Bearer ",
+			wantToken: "",
+			wantOK:    false,
+		},
+		{
+			name:      "bearer with only spaces",
+			header:    "Bearer     ",
+			wantToken: "",
+			wantOK:    false,
+		},
+		{
+			name:      "missing space after Bearer",
+			header:    "Bearertoken",
+			wantToken: "",
+			wantOK:    false,
+		},
+		{
+			name:      "different auth type",
+			header:    "Basic dXNlcjpwYXNz",
+			wantToken: "",
+			wantOK:    false,
+		},
+		{
+			name:      "empty header",
+			header:    "",
+			wantToken: "",
+			wantOK:    false,
+		},
+		{
+			name:      "token with internal spaces",
+			header:    "Bearer token with spaces",
+			wantToken: "token with spaces",
+			wantOK:    true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotToken, gotOK := parseBearerToken(tt.header)
+			if gotToken != tt.wantToken {
+				t.Errorf("parseBearerToken() token = %q, want %q", gotToken, tt.wantToken)
+			}
+			if gotOK != tt.wantOK {
+				t.Errorf("parseBearerToken() ok = %v, want %v", gotOK, tt.wantOK)
+			}
+		})
+	}
+}

operation/pull/pull.go

@@ -20,6 +20,7 @@ const (
 	GetPullRequestByIndexToolName     = "get_pull_request_by_index"
 	ListRepoPullRequestsToolName      = "list_repo_pull_requests"
 	CreatePullRequestToolName         = "create_pull_request"
+	CreatePullRequestReviewerToolName = "create_pull_request_reviewer"
 )
 
 var (
@@ -53,6 +54,16 @@ var (
 		mcp.WithString("head", mcp.Required(), mcp.Description("pull request head")),
 		mcp.WithString("base", mcp.Required(), mcp.Description("pull request base")),
 	)
+
+	CreatePullRequestReviewerTool = mcp.NewTool(
+		CreatePullRequestReviewerToolName,
+		mcp.WithDescription("create pull request reviewer"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithNumber("index", mcp.Required(), mcp.Description("pull request index")),
+		mcp.WithArray("reviewers", mcp.Description("list of reviewer usernames"), mcp.Items(map[string]interface{}{"type": "string"})),
+		mcp.WithArray("team_reviewers", mcp.Description("list of team reviewer names"), mcp.Items(map[string]interface{}{"type": "string"})),
+	)
 )
 
 func init() {
@@ -68,6 +79,10 @@ func init() {
 		Tool:    CreatePullRequestTool,
 		Handler: CreatePullRequestFn,
 	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    CreatePullRequestReviewerTool,
+		Handler: CreatePullRequestReviewerFn,
+	})
 }
 
 func GetPullRequestByIndexFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
@@ -84,7 +99,11 @@ func GetPullRequestByIndexFn(ctx context.Context, req mcp.CallToolRequest) (*mcp
 	if !ok {
 		return to.ErrorResult(fmt.Errorf("index is required"))
 	}
-	pr, _, err := gitea.Client().GetPullRequest(owner, repo, int64(index))
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	pr, _, err := client.GetPullRequest(owner, repo, int64(index))
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get %v/%v/pr/%v err: %v", owner, repo, int64(index), err))
 	}
@@ -125,7 +144,11 @@ func ListRepoPullRequestsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.
 			PageSize: int(pageSize),
 		},
 	}
-	pullRequests, _, err := gitea.Client().ListRepoPullRequests(owner, repo, opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	pullRequests, _, err := client.ListRepoPullRequests(owner, repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("list %v/%v/pull_requests err: %v", owner, repo, err))
 	}
@@ -159,7 +182,11 @@ func CreatePullRequestFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Cal
 	if !ok {
 		return to.ErrorResult(fmt.Errorf("base is required"))
 	}
-	pr, _, err := gitea.Client().CreatePullRequest(owner, repo, gitea_sdk.CreatePullRequestOption{
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	pr, _, err := client.CreatePullRequest(owner, repo, gitea_sdk.CreatePullRequestOption{
 		Title: title,
 		Body:  body,
 		Head:  head,
@@ -171,3 +198,65 @@ func CreatePullRequestFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Cal
 
 	return to.TextResult(pr)
 }
+
+func CreatePullRequestReviewerFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called CreatePullRequestReviewerFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	index, ok := req.GetArguments()["index"].(float64)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("index is required"))
+	}
+
+	var reviewers []string
+	if reviewersArg, exists := req.GetArguments()["reviewers"]; exists {
+		if reviewersSlice, ok := reviewersArg.([]interface{}); ok {
+			for _, reviewer := range reviewersSlice {
+				if reviewerStr, ok := reviewer.(string); ok {
+					reviewers = append(reviewers, reviewerStr)
+				}
+			}
+		}
+	}
+
+	var teamReviewers []string
+	if teamReviewersArg, exists := req.GetArguments()["team_reviewers"]; exists {
+		if teamReviewersSlice, ok := teamReviewersArg.([]interface{}); ok {
+			for _, teamReviewer := range teamReviewersSlice {
+				if teamReviewerStr, ok := teamReviewer.(string); ok {
+					teamReviewers = append(teamReviewers, teamReviewerStr)
+				}
+			}
+		}
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+
+	_, err = client.CreateReviewRequests(owner, repo, int64(index), gitea_sdk.PullReviewRequestOptions{
+		Reviewers:     reviewers,
+		TeamReviewers: teamReviewers,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create review requests for %v/%v/pr/%v err: %v", owner, repo, int64(index), err))
+	}
+
+	// Return a success message instead of the Response object which contains non-serializable functions
+	successMsg := map[string]interface{}{
+		"message":        "Successfully created review requests",
+		"reviewers":      reviewers,
+		"team_reviewers": teamReviewers,
+		"pr_index":       int64(index),
+		"repository":     fmt.Sprintf("%s/%s", owner, repo),
+	}
+
+	return to.TextResult(successMsg)
+}

operation/repo/branch.go

@@ -76,7 +76,11 @@ func CreateBranchFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallTool
 	}
 	oldBranch, _ := req.GetArguments()["old_branch"].(string)
 
-	_, _, err := gitea.Client().CreateBranch(owner, repo, gitea_sdk.CreateBranchOption{
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, _, err = client.CreateBranch(owner, repo, gitea_sdk.CreateBranchOption{
 		BranchName:    branch,
 		OldBranchName: oldBranch,
 	})
@@ -101,7 +105,11 @@ func DeleteBranchFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallTool
 	if !ok {
 		return to.ErrorResult(fmt.Errorf("branch is required"))
 	}
-	_, _, err := gitea.Client().DeleteRepoBranch(owner, repo, branch)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, _, err = client.DeleteRepoBranch(owner, repo, branch)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("delete branch error: %v", err))
 	}
@@ -125,7 +133,11 @@ func ListBranchesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallTool
 			PageSize: 100,
 		},
 	}
-	branches, _, err := gitea.Client().ListRepoBranches(owner, repo, opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	branches, _, err := client.ListRepoBranches(owner, repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("list branches error: %v", err))
 	}

operation/repo/commit.go

@@ -63,7 +63,11 @@ func ListRepoCommitsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallT
 		SHA:  sha,
 		Path: path,
 	}
-	commits, _, err := gitea.Client().ListRepoCommits(owner, repo, opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	commits, _, err := client.ListRepoCommits(owner, repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("list repo commits err: %v", err))
 	}

operation/repo/file.go

@@ -1,8 +1,11 @@
 package repo
 
 import (
+	"bufio"
+	"bytes"
 	"context"
 	"encoding/base64"
+	"encoding/json"
 	"fmt"
 
 	"gitea.com/gitea/gitea-mcp/pkg/gitea"
@@ -30,6 +33,7 @@ var (
 		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
 		mcp.WithString("ref", mcp.Required(), mcp.Description("ref can be branch/tag/commit")),
 		mcp.WithString("filePath", mcp.Required(), mcp.Description("file path")),
+		mcp.WithBoolean("withLines", mcp.Description("whether to return file content with lines")),
 	)
 
 	GetDirContentTool = mcp.NewTool(
@@ -60,7 +64,7 @@ var (
 		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
 		mcp.WithString("filePath", mcp.Required(), mcp.Description("file path")),
 		mcp.WithString("sha", mcp.Required(), mcp.Description("sha is the SHA for the file that already exists")),
-		mcp.WithString("content", mcp.Required(), mcp.Description("file content, base64 encoded")),
+		mcp.WithString("content", mcp.Required(), mcp.Description("file content")),
 		mcp.WithString("message", mcp.Required(), mcp.Description("commit message")),
 		mcp.WithString("branch_name", mcp.Required(), mcp.Description("branch name")),
 	)
@@ -100,6 +104,11 @@ func init() {
 	})
 }
 
+type ContentLine struct {
+	LineNumber int    `json:"line"`
+	Content    string `json:"content"`
+}
+
 func GetFileContentFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 	log.Debugf("Called GetFileFn")
 	owner, ok := req.GetArguments()["owner"].(string)
@@ -115,10 +124,52 @@ func GetFileContentFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallTo
 	if !ok {
 		return to.ErrorResult(fmt.Errorf("filePath is required"))
 	}
-	content, _, err := gitea.Client().GetContents(owner, repo, ref, filePath)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	content, _, err := client.GetContents(owner, repo, ref, filePath)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get file err: %v", err))
 	}
+	withLines, _ := req.GetArguments()["withLines"].(bool)
+	if withLines {
+		rawContent, err := base64.StdEncoding.DecodeString(*content.Content)
+		if err != nil {
+			return to.ErrorResult(fmt.Errorf("decode base64 content err: %v", err))
+		}
+
+		contentLines := make([]ContentLine, 0)
+		line := 0
+
+		scanner := bufio.NewScanner(bytes.NewReader(rawContent))
+
+		for scanner.Scan() {
+			line++
+
+			contentLines = append(contentLines, ContentLine{
+				LineNumber: line,
+				Content:    scanner.Text(),
+			})
+
+		}
+		if err := scanner.Err(); err != nil {
+			return to.ErrorResult(fmt.Errorf("scan content err: %v", err))
+		}
+
+		// remove the last blank line if exists
+		// git does not consider the last line as a new line
+		if contentLines[len(contentLines)-1].Content == "" {
+			contentLines = contentLines[:len(contentLines)-1]
+		}
+
+		contentBytes, err := json.MarshalIndent(contentLines, "", "  ")
+		if err != nil {
+			return to.ErrorResult(fmt.Errorf("marshal content lines err: %v", err))
+		}
+		contentStr := string(contentBytes)
+		content.Content = &contentStr
+	}
 	return to.TextResult(content)
 }
 
@@ -137,7 +188,11 @@ func GetDirContentFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToo
 	if !ok {
 		return to.ErrorResult(fmt.Errorf("filePath is required"))
 	}
-	content, _, err := gitea.Client().ListContents(owner, repo, ref, filePath)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	content, _, err := client.ListContents(owner, repo, ref, filePath)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get dir content err: %v", err))
 	}
@@ -169,7 +224,11 @@ func CreateFileFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRe
 		},
 	}
 
-	_, _, err := gitea.Client().CreateFile(owner, repo, filePath, opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, _, err = client.CreateFile(owner, repo, filePath, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("create file err: %v", err))
 	}
@@ -206,7 +265,11 @@ func UpdateFileFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRe
 			BranchName: branchName,
 		},
 	}
-	_, _, err := gitea.Client().UpdateFile(owner, repo, filePath, opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, _, err = client.UpdateFile(owner, repo, filePath, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("update file err: %v", err))
 	}
@@ -240,7 +303,11 @@ func DeleteFileFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRe
 		},
 		SHA: sha,
 	}
-	_, err := gitea.Client().DeleteFile(owner, repo, filePath, opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.DeleteFile(owner, repo, filePath, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("delete file err: %v", err))
 	}

operation/repo/release.go

@@ -34,6 +34,7 @@ var (
 		mcp.WithString("title", mcp.Required(), mcp.Description("release title")),
 		mcp.WithBoolean("is_draft", mcp.Description("Whether the release is draft"), mcp.DefaultBool(false)),
 		mcp.WithBoolean("is_pre_release", mcp.Description("Whether the release is pre-release"), mcp.DefaultBool(false)),
+		mcp.WithString("body", mcp.Description("release body")),
 	)
 
 	DeleteReleaseTool = mcp.NewTool(
@@ -131,11 +132,17 @@ func CreateReleaseFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToo
 	}
 	isDraft, _ := req.GetArguments()["is_draft"].(bool)
 	isPreRelease, _ := req.GetArguments()["is_pre_release"].(bool)
+	body, _ := req.GetArguments()["body"].(string)
 
-	_, _, err := gitea.Client().CreateRelease(owner, repo, gitea_sdk.CreateReleaseOption{
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, _, err = client.CreateRelease(owner, repo, gitea_sdk.CreateReleaseOption{
 		TagName:      tagName,
 		Target:       target,
 		Title:        title,
+		Note:         body,
 		IsDraft:      isDraft,
 		IsPrerelease: isPreRelease,
 	})
@@ -161,7 +168,11 @@ func DeleteReleaseFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToo
 		return nil, fmt.Errorf("id is required")
 	}
 
-	_, err := gitea.Client().DeleteRelease(owner, repo, int64(id))
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.DeleteRelease(owner, repo, int64(id))
 	if err != nil {
 		return nil, fmt.Errorf("delete release error: %v", err)
 	}
@@ -184,7 +195,11 @@ func GetReleaseFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRe
 		return nil, fmt.Errorf("id is required")
 	}
 
-	release, _, err := gitea.Client().GetRelease(owner, repo, int64(id))
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	release, _, err := client.GetRelease(owner, repo, int64(id))
 	if err != nil {
 		return nil, fmt.Errorf("get release error: %v", err)
 	}
@@ -203,7 +218,11 @@ func GetLatestReleaseFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Call
 		return nil, fmt.Errorf("repo is required")
 	}
 
-	release, _, err := gitea.Client().GetLatestRelease(owner, repo)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	release, _, err := client.GetLatestRelease(owner, repo)
 	if err != nil {
 		return nil, fmt.Errorf("get latest release error: %v", err)
 	}
@@ -234,7 +253,11 @@ func ListReleasesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallTool
 	page, _ := req.GetArguments()["page"].(float64)
 	pageSize, _ := req.GetArguments()["pageSize"].(float64)
 
-	releases, _, err := gitea.Client().ListReleases(owner, repo, gitea_sdk.ListReleasesOptions{
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	releases, _, err := client.ListReleases(owner, repo, gitea_sdk.ListReleasesOptions{
 		ListOptions: gitea_sdk.ListOptions{
 			Page:     int(page),
 			PageSize: int(pageSize),

operation/repo/repo.go

@@ -27,7 +27,7 @@ const (
 var (
 	CreateRepoTool = mcp.NewTool(
 		CreateRepoToolName,
-		mcp.WithDescription("Create repository"),
+		mcp.WithDescription("Create repository in personal account or organization"),
 		mcp.WithString("name", mcp.Required(), mcp.Description("Name of the repository to create")),
 		mcp.WithString("description", mcp.Description("Description of the repository to create")),
 		mcp.WithBoolean("private", mcp.Description("Whether the repository is private")),
@@ -38,6 +38,7 @@ var (
 		mcp.WithString("license", mcp.Description("License to use")),
 		mcp.WithString("readme", mcp.Description("Readme of the repository to create")),
 		mcp.WithString("default_branch", mcp.Description("DefaultBranch of the repository (used when initializes and in template)")),
+		mcp.WithString("organization", mcp.Description("Organization name to create repository in (optional - defaults to personal account)")),
 	)
 
 	ForkRepoTool = mcp.NewTool(
@@ -120,6 +121,7 @@ func CreateRepoFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRe
 	license, _ := req.GetArguments()["license"].(string)
 	readme, _ := req.GetArguments()["readme"].(string)
 	defaultBranch, _ := req.GetArguments()["default_branch"].(string)
+	organization, _ := req.GetArguments()["organization"].(string)
 
 	opt := gitea_sdk.CreateRepoOption{
 		Name:          name,
@@ -133,9 +135,22 @@ func CreateRepoFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRe
 		Readme:        readme,
 		DefaultBranch: defaultBranch,
 	}
-	repo, _, err := gitea.Client().CreateRepo(opt)
+
+	var repo *gitea_sdk.Repository
+	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
-		return to.ErrorResult(fmt.Errorf("create repo err: %v", err))
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	if organization != "" {
+		repo, _, err = client.CreateOrgRepo(organization, opt)
+		if err != nil {
+			return to.ErrorResult(fmt.Errorf("create organization repository '%s' in '%s' err: %v", name, organization, err))
+		}
+	} else {
+		repo, _, err = client.CreateRepo(opt)
+		if err != nil {
+			return to.ErrorResult(fmt.Errorf("create repository '%s' err: %v", name, err))
+		}
 	}
 	return to.TextResult(repo)
 }
@@ -164,7 +179,11 @@ func ForkRepoFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResu
 		Organization: organizationPtr,
 		Name:         namePtr,
 	}
-	_, _, err := gitea.Client().CreateFork(user, repo, opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, _, err = client.CreateFork(user, repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("fork repository error: %v", err))
 	}
@@ -187,7 +206,11 @@ func ListMyReposFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolR
 			PageSize: int(pageSize),
 		},
 	}
-	repos, _, err := gitea.Client().ListMyRepos(opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	repos, _, err := client.ListMyRepos(opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("list my repositories error: %v", err))
 	}

operation/repo/tag.go

@@ -102,7 +102,11 @@ func CreateTagFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRes
 	target, _ := req.GetArguments()["target"].(string)
 	message, _ := req.GetArguments()["message"].(string)
 
-	_, _, err := gitea.Client().CreateTag(owner, repo, gitea_sdk.CreateTagOption{
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, _, err = client.CreateTag(owner, repo, gitea_sdk.CreateTagOption{
 		TagName: tagName,
 		Target:  target,
 		Message: message,
@@ -129,7 +133,11 @@ func DeleteTagFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolRes
 		return nil, fmt.Errorf("tag_name is required")
 	}
 
-	_, err := gitea.Client().DeleteTag(owner, repo, tagName)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.DeleteTag(owner, repo, tagName)
 	if err != nil {
 		return nil, fmt.Errorf("delete tag error: %v", err)
 	}
@@ -152,7 +160,11 @@ func GetTagFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult
 		return nil, fmt.Errorf("tag_name is required")
 	}
 
-	tag, _, err := gitea.Client().GetTag(owner, repo, tagName)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	tag, _, err := client.GetTag(owner, repo, tagName)
 	if err != nil {
 		return nil, fmt.Errorf("get tag error: %v", err)
 	}
@@ -173,7 +185,11 @@ func ListTagsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResu
 	page, _ := req.GetArguments()["page"].(float64)
 	pageSize, _ := req.GetArguments()["pageSize"].(float64)
 
-	tags, _, err := gitea.Client().ListRepoTags(owner, repo, gitea_sdk.ListRepoTagsOptions{
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	tags, _, err := client.ListRepoTags(owner, repo, gitea_sdk.ListRepoTagsOptions{
 		ListOptions: gitea_sdk.ListOptions{
 			Page:     int(page),
 			PageSize: int(pageSize),

operation/search/search.go

@@ -94,7 +94,11 @@ func SearchUsersFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolR
 			PageSize: int(pageSize),
 		},
 	}
-	users, _, err := gitea.Client().SearchUsers(opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	users, _, err := client.SearchUsers(opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("search users err: %v", err))
 	}
@@ -128,7 +132,11 @@ func SearchOrgTeamsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallTo
 			PageSize: int(pageSize),
 		},
 	}
-	teams, _, err := gitea.Client().SearchOrgTeams(org, &opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	teams, _, err := client.SearchOrgTeams(org, &opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("search organization teams error: %v", err))
 	}
@@ -178,7 +186,11 @@ func SearchReposFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolR
 			PageSize: int(pageSize),
 		},
 	}
-	repos, _, err := gitea.Client().SearchRepos(opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	repos, _, err := client.SearchRepos(opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("search repos error: %v", err))
 	}

operation/user/user.go

@@ -15,68 +15,102 @@ import (
 )
 
 const (
+	// GetMyUserInfoToolName is the unique tool name used for MCP registration and lookup of the get_my_user_info command.
 	GetMyUserInfoToolName = "get_my_user_info"
+	// GetUserOrgsToolName is the unique tool name used for MCP registration and lookup of the get_user_orgs command.
 	GetUserOrgsToolName = "get_user_orgs"
+
+	// defaultPage is the default starting page number used for paginated organization listings.
+	defaultPage = 1
+	// defaultPageSize is the default number of organizations per page for paginated queries.
+	defaultPageSize = 100
 )
 
+// Tool is the MCP tool manager instance for registering all MCP tools in this package.
 var Tool = tool.New()
 
 var (
+	// GetMyUserInfoTool is the MCP tool for retrieving the current user's info.
+	// It is registered with a specific name and a description string.
 	GetMyUserInfoTool = mcp.NewTool(
 		GetMyUserInfoToolName,
 		mcp.WithDescription("Get my user info"),
 	)
 
+	// GetUserOrgsTool is the MCP tool for listing organizations for the authenticated user.
+	// It supports pagination via "page" and "pageSize" arguments with default values specified above.
 	GetUserOrgsTool = mcp.NewTool(
 		GetUserOrgsToolName,
 		mcp.WithDescription("Get organizations associated with the authenticated user"),
-		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1)),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(defaultPage)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100)),
+		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(defaultPageSize)),
 	)
 )
 
+// init registers all MCP tools in Tool at package initialization.
+// This function ensures the handler functions are registered before server usage.
 func init() {
-	Tool.RegisterRead(server.ServerTool{
+	registerTools()
-		Tool:    GetMyUserInfoTool,
-		Handler: GetUserInfoFn,
-	})
-
-	Tool.RegisterRead(server.ServerTool{
-		Tool:    GetUserOrgsTool,
-		Handler: GetUserOrgsFn,
-	})
 }
 
+// registerTools registers all local MCP tool definitions and their handler functions.
+// To add new functionality, append your tool/handler pair to the tools slice below.
+func registerTools() {
+	tools := []server.ServerTool{
+		{Tool: GetMyUserInfoTool, Handler: GetUserInfoFn},
+		{Tool: GetUserOrgsTool, Handler: GetUserOrgsFn},
+	}
+	for _, t := range tools {
+		Tool.RegisterRead(t)
+	}
+}
+
+// getIntArg parses an integer argument from the MCP request arguments map.
+// Returns def if missing, not a number, or less than 1. Used for pagination arguments.
+func getIntArg(req mcp.CallToolRequest, name string, def int) int {
+	val, ok := req.GetArguments()[name].(float64)
+	if !ok || val < 1 {
+		return def
+	}
+	return int(val)
+}
+
+// GetUserInfoFn is the handler for "get_my_user_info" MCP tool requests.
+// Logs invocation, fetches current user info from gitea, wraps result for MCP.
 func GetUserInfoFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called GetUserInfoFn")
+	log.Debugf("[User] Called GetUserInfoFn")
-	user, _, err := gitea.Client().GetMyUserInfo()
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	user, _, err := client.GetMyUserInfo()
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get user info err: %v", err))
 	}
-
 	return to.TextResult(user)
 }
 
+// GetUserOrgsFn is the handler for "get_user_orgs" MCP tool requests.
+// Logs invocation, pulls validated pagination arguments from request,
+// performs Gitea organization listing, and wraps the result for MCP.
 func GetUserOrgsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called GetUserOrgsFn")
+	log.Debugf("[User] Called GetUserOrgsFn")
-	page, ok := req.GetArguments()["page"].(float64)
+	page := getIntArg(req, "page", defaultPage)
-	if !ok || page < 1 {
+	pageSize := getIntArg(req, "pageSize", defaultPageSize)
-		page = 1
+
-	}
-	pageSize, ok := req.GetArguments()["pageSize"].(float64)
-	if !ok || pageSize < 1 {
-		pageSize = 100
-	}
 	opt := gitea_sdk.ListOrgsOptions{
 		ListOptions: gitea_sdk.ListOptions{
-			Page:     int(page),
+			Page:     page,
-			PageSize: int(pageSize),
+			PageSize: pageSize,
 		},
 	}
-	orgs, _, err := gitea.Client().ListMyOrgs(opt)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	orgs, _, err := client.ListMyOrgs(opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get user orgs err: %v", err))
 	}
-
 	return to.TextResult(orgs)
 }

operation/wiki/wiki.go

@@ -0,0 +1,284 @@
+package wiki
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/log"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+	"gitea.com/gitea/gitea-mcp/pkg/tool"
+
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+var Tool = tool.New()
+
+const (
+	ListWikiPagesToolName    = "list_wiki_pages"
+	GetWikiPageToolName      = "get_wiki_page"
+	GetWikiRevisionsToolName = "get_wiki_revisions"
+	CreateWikiPageToolName   = "create_wiki_page"
+	UpdateWikiPageToolName   = "update_wiki_page"
+	DeleteWikiPageToolName   = "delete_wiki_page"
+)
+
+var (
+	ListWikiPagesTool = mcp.NewTool(
+		ListWikiPagesToolName,
+		mcp.WithDescription("List all wiki pages in a repository"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+	)
+
+	GetWikiPageTool = mcp.NewTool(
+		GetWikiPageToolName,
+		mcp.WithDescription("Get a wiki page content and metadata"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("pageName", mcp.Required(), mcp.Description("wiki page name")),
+	)
+
+	GetWikiRevisionsTool = mcp.NewTool(
+		GetWikiRevisionsToolName,
+		mcp.WithDescription("Get revisions history of a wiki page"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("pageName", mcp.Required(), mcp.Description("wiki page name")),
+	)
+
+	CreateWikiPageTool = mcp.NewTool(
+		CreateWikiPageToolName,
+		mcp.WithDescription("Create a new wiki page"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("title", mcp.Required(), mcp.Description("wiki page title")),
+		mcp.WithString("content_base64", mcp.Required(), mcp.Description("page content, base64 encoded")),
+		mcp.WithString("message", mcp.Description("commit message (optional)")),
+	)
+
+	UpdateWikiPageTool = mcp.NewTool(
+		UpdateWikiPageToolName,
+		mcp.WithDescription("Update an existing wiki page"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("pageName", mcp.Required(), mcp.Description("current wiki page name")),
+		mcp.WithString("title", mcp.Description("new page title (optional)")),
+		mcp.WithString("content_base64", mcp.Required(), mcp.Description("page content, base64 encoded")),
+		mcp.WithString("message", mcp.Description("commit message (optional)")),
+	)
+
+	DeleteWikiPageTool = mcp.NewTool(
+		DeleteWikiPageToolName,
+		mcp.WithDescription("Delete a wiki page"),
+		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
+		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("pageName", mcp.Required(), mcp.Description("wiki page name to delete")),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(server.ServerTool{
+		Tool:    ListWikiPagesTool,
+		Handler: ListWikiPagesFn,
+	})
+	Tool.RegisterRead(server.ServerTool{
+		Tool:    GetWikiPageTool,
+		Handler: GetWikiPageFn,
+	})
+	Tool.RegisterRead(server.ServerTool{
+		Tool:    GetWikiRevisionsTool,
+		Handler: GetWikiRevisionsFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    CreateWikiPageTool,
+		Handler: CreateWikiPageFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    UpdateWikiPageTool,
+		Handler: UpdateWikiPageFn,
+	})
+	Tool.RegisterWrite(server.ServerTool{
+		Tool:    DeleteWikiPageTool,
+		Handler: DeleteWikiPageFn,
+	})
+}
+
+func ListWikiPagesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called ListWikiPagesFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+
+	// Use direct HTTP request because SDK does not support yet wikis
+	var result any
+	_, err := gitea.DoJSON(ctx, "GET", fmt.Sprintf("repos/%s/%s/wiki/pages", url.QueryEscape(owner), url.QueryEscape(repo)), nil, nil, &result)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list wiki pages err: %v", err))
+	}
+
+	return to.TextResult(result)
+}
+
+func GetWikiPageFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetWikiPageFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	pageName, ok := req.GetArguments()["pageName"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("pageName is required"))
+	}
+
+	var result any
+	_, err := gitea.DoJSON(ctx, "GET", fmt.Sprintf("repos/%s/%s/wiki/page/%s", url.QueryEscape(owner), url.QueryEscape(repo), url.QueryEscape(pageName)), nil, nil, &result)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get wiki page err: %v", err))
+	}
+
+	return to.TextResult(result)
+}
+
+func GetWikiRevisionsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called GetWikiRevisionsFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	pageName, ok := req.GetArguments()["pageName"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("pageName is required"))
+	}
+
+	var result any
+	_, err := gitea.DoJSON(ctx, "GET", fmt.Sprintf("repos/%s/%s/wiki/revisions/%s", url.QueryEscape(owner), url.QueryEscape(repo), url.QueryEscape(pageName)), nil, nil, &result)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get wiki revisions err: %v", err))
+	}
+
+	return to.TextResult(result)
+}
+
+func CreateWikiPageFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called CreateWikiPageFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	title, ok := req.GetArguments()["title"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("title is required"))
+	}
+	contentBase64, ok := req.GetArguments()["content_base64"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("content_base64 is required"))
+	}
+
+	message, _ := req.GetArguments()["message"].(string)
+	if message == "" {
+		message = fmt.Sprintf("Create wiki page '%s'", title)
+	}
+
+	requestBody := map[string]string{
+		"title":          title,
+		"content_base64": contentBase64,
+		"message":        message,
+	}
+
+	var result any
+	_, err := gitea.DoJSON(ctx, "POST", fmt.Sprintf("repos/%s/%s/wiki/new", url.QueryEscape(owner), url.QueryEscape(repo)), nil, requestBody, &result)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create wiki page err: %v", err))
+	}
+
+	return to.TextResult(result)
+}
+
+func UpdateWikiPageFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called UpdateWikiPageFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	pageName, ok := req.GetArguments()["pageName"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("pageName is required"))
+	}
+	contentBase64, ok := req.GetArguments()["content_base64"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("content_base64 is required"))
+	}
+
+	requestBody := map[string]string{
+		"content_base64": contentBase64,
+	}
+
+	// If title is given, use it. Otherwise, keep current page name
+	if title, ok := req.GetArguments()["title"].(string); ok && title != "" {
+		requestBody["title"] = title
+	} else {
+		// Utiliser pageName comme fallback pour éviter "unnamed"
+		requestBody["title"] = pageName
+	}
+
+	if message, ok := req.GetArguments()["message"].(string); ok && message != "" {
+		requestBody["message"] = message
+	} else {
+		requestBody["message"] = fmt.Sprintf("Update wiki page '%s'", pageName)
+	}
+
+	var result any
+	_, err := gitea.DoJSON(ctx, "PATCH", fmt.Sprintf("repos/%s/%s/wiki/page/%s", url.QueryEscape(owner), url.QueryEscape(repo), url.QueryEscape(pageName)), nil, requestBody, &result)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("update wiki page err: %v", err))
+	}
+
+	return to.TextResult(result)
+}
+
+func DeleteWikiPageFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called DeleteWikiPageFn")
+	owner, ok := req.GetArguments()["owner"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("owner is required"))
+	}
+	repo, ok := req.GetArguments()["repo"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("repo is required"))
+	}
+	pageName, ok := req.GetArguments()["pageName"].(string)
+	if !ok {
+		return to.ErrorResult(fmt.Errorf("pageName is required"))
+	}
+
+	_, err := gitea.DoJSON(ctx, "DELETE", fmt.Sprintf("repos/%s/%s/wiki/page/%s", url.QueryEscape(owner), url.QueryEscape(repo), url.QueryEscape(pageName)), nil, nil, nil)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete wiki page err: %v", err))
+	}
+
+	return to.TextResult(map[string]string{"message": "Wiki page deleted successfully"})
+}

pkg/context/context.go

@@ -0,0 +1,7 @@
+package context
+
+type contextKey string
+
+const (
+	TokenContextKey = contextKey("token")
+)

pkg/gitea/gitea.go

@@ -1,34 +1,23 @@
 package gitea
 
 import (
+	"context"
 	"crypto/tls"
+	"fmt"
 	"net/http"
-	"sync"
-
-	"gitea.com/gitea/gitea-mcp/pkg/flag"
-	"gitea.com/gitea/gitea-mcp/pkg/log"
 
 	"code.gitea.io/sdk/gitea"
+	mcpContext "gitea.com/gitea/gitea-mcp/pkg/context"
+	"gitea.com/gitea/gitea-mcp/pkg/flag"
 )
 
-var (
+func NewClient(token string) (*gitea.Client, error) {
-	client     *gitea.Client
-	clientOnce sync.Once
-)
-
-func Client() *gitea.Client {
-	clientOnce.Do(func() {
-		var err error
-		if client != nil {
-			return
-		}
-
 	httpClient := &http.Client{
 		Transport: http.DefaultTransport,
 	}
 
 	opts := []gitea.ClientOption{
-			gitea.SetToken(flag.Token),
+		gitea.SetToken(token),
 	}
 	if flag.Insecure {
 		httpClient.Transport.(*http.Transport).TLSClientConfig = &tls.Config{
@@ -39,10 +28,20 @@ func Client() *gitea.Client {
 	if flag.Debug {
 		opts = append(opts, gitea.SetDebugMode())
 	}
-		client, err = gitea.NewClient(flag.Host, opts...)
+	client, err := gitea.NewClient(flag.Host, opts...)
 	if err != nil {
-			log.Fatalf("create gitea client err: %v", err)
+		return nil, fmt.Errorf("create gitea client err: %w", err)
 	}
-	})
+
-	return client
+	// Set user agent for the client
+	client.SetUserAgent(fmt.Sprintf("gitea-mcp-server/%s", flag.Version))
+	return client, nil
+}
+
+func ClientFromContext(ctx context.Context) (*gitea.Client, error) {
+	token, ok := ctx.Value(mcpContext.TokenContextKey).(string)
+	if !ok {
+		token = flag.Token
+	}
+	return NewClient(token)
 }

pkg/gitea/rest.go

@@ -0,0 +1,175 @@
+package gitea
+
+import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	mcpContext "gitea.com/gitea/gitea-mcp/pkg/context"
+	"gitea.com/gitea/gitea-mcp/pkg/flag"
+)
+
+type HTTPError struct {
+	StatusCode int
+	Body       string
+}
+
+func (e *HTTPError) Error() string {
+	if e.Body == "" {
+		return fmt.Sprintf("request failed with status %d", e.StatusCode)
+	}
+	return fmt.Sprintf("request failed with status %d: %s", e.StatusCode, e.Body)
+}
+
+func tokenFromContext(ctx context.Context) string {
+	if ctx != nil {
+		if token, ok := ctx.Value(mcpContext.TokenContextKey).(string); ok && token != "" {
+			return token
+		}
+	}
+	return flag.Token
+}
+
+func newRESTHTTPClient() *http.Client {
+	transport := http.DefaultTransport.(*http.Transport).Clone()
+	if flag.Insecure {
+		transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true} //nolint:gosec
+	}
+	return &http.Client{
+		Transport: transport,
+		Timeout:   60 * time.Second,
+	}
+}
+
+func buildAPIURL(path string, query url.Values) (string, error) {
+	host := strings.TrimRight(flag.Host, "/")
+	if host == "" {
+		return "", fmt.Errorf("gitea host is empty")
+	}
+	p := strings.TrimLeft(path, "/")
+	u, err := url.Parse(fmt.Sprintf("%s/api/v1/%s", host, p))
+	if err != nil {
+		return "", err
+	}
+	if query != nil {
+		u.RawQuery = query.Encode()
+	}
+	return u.String(), nil
+}
+
+// DoJSON performs an API request and decodes a JSON response into respOut (if non-nil).
+// It returns the HTTP status code.
+func DoJSON(ctx context.Context, method, path string, query url.Values, body any, respOut any) (int, error) {
+	var bodyReader io.Reader
+	if body != nil {
+		b, err := json.Marshal(body)
+		if err != nil {
+			return 0, fmt.Errorf("marshal request body: %w", err)
+		}
+		bodyReader = bytes.NewReader(b)
+	}
+
+	u, err := buildAPIURL(path, query)
+	if err != nil {
+		return 0, err
+	}
+	req, err := http.NewRequestWithContext(ctx, method, u, bodyReader)
+	if err != nil {
+		return 0, fmt.Errorf("create request: %w", err)
+	}
+
+	token := tokenFromContext(ctx)
+	if token != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("token %s", token))
+	}
+	req.Header.Set("Accept", "application/json")
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
+	client := newRESTHTTPClient()
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, fmt.Errorf("do request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		bodySnippet, _ := io.ReadAll(io.LimitReader(resp.Body, 8192))
+		return resp.StatusCode, &HTTPError{StatusCode: resp.StatusCode, Body: strings.TrimSpace(string(bodySnippet))}
+	}
+
+	if respOut == nil {
+		io.Copy(io.Discard, resp.Body) // best-effort
+		return resp.StatusCode, nil
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(respOut); err != nil {
+		return resp.StatusCode, fmt.Errorf("decode response: %w", err)
+	}
+	return resp.StatusCode, nil
+}
+
+// DoBytes performs an API request and returns the raw response bytes.
+// It returns the HTTP status code.
+func DoBytes(ctx context.Context, method, path string, query url.Values, body any, accept string) ([]byte, int, error) {
+	var bodyReader io.Reader
+	if body != nil {
+		b, err := json.Marshal(body)
+		if err != nil {
+			return nil, 0, fmt.Errorf("marshal request body: %w", err)
+		}
+		bodyReader = bytes.NewReader(b)
+	}
+
+	u, err := buildAPIURL(path, query)
+	if err != nil {
+		return nil, 0, err
+	}
+	req, err := http.NewRequestWithContext(ctx, method, u, bodyReader)
+	if err != nil {
+		return nil, 0, fmt.Errorf("create request: %w", err)
+	}
+
+	token := tokenFromContext(ctx)
+	if token != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("token %s", token))
+	}
+	if accept != "" {
+		req.Header.Set("Accept", accept)
+	}
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
+	client := newRESTHTTPClient()
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, 0, fmt.Errorf("do request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	respBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, resp.StatusCode, fmt.Errorf("read response: %w", err)
+	}
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		bodySnippet := respBytes
+		if len(bodySnippet) > 8192 {
+			bodySnippet = bodySnippet[:8192]
+		}
+		return nil, resp.StatusCode, &HTTPError{StatusCode: resp.StatusCode, Body: strings.TrimSpace(string(bodySnippet))}
+	}
+
+	return respBytes, resp.StatusCode, nil
+}
+
+

pkg/gitea/rest_test.go

@@ -0,0 +1,32 @@
+package gitea
+
+import (
+	"context"
+	"testing"
+
+	mcpContext "gitea.com/gitea/gitea-mcp/pkg/context"
+	"gitea.com/gitea/gitea-mcp/pkg/flag"
+)
+
+func TestTokenFromContext(t *testing.T) {
+	orig := flag.Token
+	defer func() { flag.Token = orig }()
+
+	flag.Token = "flag-token"
+
+	t.Run("context token wins", func(t *testing.T) {
+		ctx := context.WithValue(context.Background(), mcpContext.TokenContextKey, "ctx-token")
+		if got := tokenFromContext(ctx); got != "ctx-token" {
+			t.Fatalf("tokenFromContext() = %q, want %q", got, "ctx-token")
+		}
+	})
+
+	t.Run("fallback to flag token", func(t *testing.T) {
+		ctx := context.Background()
+		if got := tokenFromContext(ctx); got != "flag-token" {
+			t.Fatalf("tokenFromContext() = %q, want %q", got, "flag-token")
+		}
+	})
+}
+
+

pkg/log/log.go

@@ -48,7 +48,7 @@ func Default() *zap.Logger {
 			MaxAge:     30,
 		}))
 
-		if flag.Mode == "http" || flag.Mode == "sse" {
+		if flag.Mode == "http" {
 			wss = append(wss, zapcore.AddSync(os.Stdout))
 		}