feat(project): add project management tools

Add read and write tools for Gitea projects, including project and column CRUD and issue-to-project-column management.

Bump gitea.dev/sdk to include ProjectsService.

Assisted-by: Codet:codet-internal

README.md

@@ -156,6 +156,8 @@ Once configured, try `list all my repositories` in the chat box.
 | timetracking_write           | timetracking | Write  | Write time tracking: stopwatches and entries |
 | package_read                 | packages     | Read   | Read package registry: list packages, list versions, or get a version |
 | package_write                | packages     | Write  | Delete a package version (irreversible) |
+| project_read                 | project      | Read   | Read projects: list projects, get a project, list columns, get a column, or list issues in a column |
+| project_write                | project      | Write  | Write projects: create, update, or delete projects and columns; reorder columns; add, remove, or move issues |
 | list_issues                  | issue        | Read   | List repository issues |
 | attachment_read              | issue        | Read   | Read issue/comment attachments: list metadata, get metadata, or download content |
 | issue_read                   | issue        | Read   | Read issue: details, comments, or labels |
@@ -191,8 +193,6 @@ Once configured, try `list all my repositories` in the chat box.
 | get_release                  | release      | Read   | Get a release by ID |
 | get_latest_release           | release      | Read   | Get the latest release |
 | list_releases                | release      | Read   | List repository releases |
-| search                       | connector    | Read   | Search Gitea repositories by keyword for ChatGPT-style connectors |
-| fetch                        | connector    | Read   | Fetch a file's decoded content and metadata for ChatGPT-style connectors |
 
 > **Note:** Several tools are consolidated, action-based tools, a single tool exposes multiple operations through a `method` parameter. Tools with `Write` access are hidden when the server runs in read-only mode (`-r` / `GITEA_READONLY`), and the exposed tool set can be filtered by scope with `-S` / `--scope` (`GITEA_SCOPES`) and/or by individual tool name with `-O` / `--tools` (`GITEA_TOOLS`).
 

README.zh-cn.md

@@ -156,6 +156,8 @@ Cursor 等客户端可使用 stdio 命令：
 | timetracking_write           | timetracking | 写入 | 写入时间跟踪：计时器和记录条目 |
 | package_read                 | packages     | 读取 | 读取软件包注册表：列出软件包、列出版本或获取某个版本 |
 | package_write                | packages     | 写入 | 删除软件包版本（不可恢复） |
+| project_read                 | project      | 读取 | 读取项目：列出项目、获取项目、列出列、获取列或列出列中的议题 |
+| project_write                | project      | 写入 | 写入项目：创建、更新或删除项目与列；重新排序列；添加、移除或移动议题 |
 | list_issues                  | issue        | 读取 | 列出仓库问题 |
 | attachment_read              | issue        | 读取 | 读取问题/评论附件：列出元数据、获取元数据或下载内容 |
 | issue_read                   | issue        | 读取 | 读取问题：详情、评论或标签 |
@@ -191,8 +193,6 @@ Cursor 等客户端可使用 stdio 命令：
 | get_release                  | release      | 读取 | 按 ID 获取版本发布 |
 | get_latest_release           | release      | 读取 | 获取最新版本发布 |
 | list_releases                | release      | 读取 | 列出仓库版本发布 |
-| search                       | connector    | 读取 | 为 ChatGPT 风格的连接器按关键字搜索 Gitea 仓库 |
-| fetch                        | connector    | 读取 | 为 ChatGPT 风格的连接器获取文件的解码内容与元数据 |
 
 > **说明：** 部分工具是聚合的、基于操作的工具，单个工具通过 `method` 参数暴露多个操作。当服务器以只读模式运行时（`-r` / `GITEA_READONLY`），访问为「写入」的工具会被隐藏；可通过 `-S` / `--scope`（`GITEA_SCOPES`）按范围过滤，或通过 `-O` / `--tools`（`GITEA_TOOLS`）按工具名称过滤对外暴露的工具集合。
 

README.zh-tw.md

@@ -156,6 +156,8 @@ Cursor 等客戶端可使用 stdio 命令：
 | timetracking_write           | timetracking | 寫入 | 寫入時間追蹤：計時器和記錄項目 |
 | package_read                 | packages     | 讀取 | 讀取軟體套件註冊表：列出套件、列出版本或取得某個版本 |
 | package_write                | packages     | 寫入 | 刪除軟體套件版本（不可復原） |
+| project_read                 | project      | 讀取 | 讀取專案：列出專案、取得專案、列出欄、取得欄或列出欄中的議題 |
+| project_write                | project      | 寫入 | 寫入專案：建立、更新或刪除專案與欄；重新排序欄；新增、移除或移動議題 |
 | list_issues                  | issue        | 讀取 | 列出倉庫問題 |
 | attachment_read              | issue        | 讀取 | 讀取問題/評論附件：列出中繼資料、取得中繼資料或下載內容 |
 | issue_read                   | issue        | 讀取 | 讀取問題：詳情、評論或標籤 |
@@ -191,8 +193,6 @@ Cursor 等客戶端可使用 stdio 命令：
 | get_release                  | release      | 讀取 | 依 ID 取得版本發布 |
 | get_latest_release           | release      | 讀取 | 取得最新版本發布 |
 | list_releases                | release      | 讀取 | 列出倉庫版本發布 |
-| search                       | connector    | 讀取 | 為 ChatGPT 風格的連接器依關鍵字搜尋 Gitea 倉庫 |
-| fetch                        | connector    | 讀取 | 為 ChatGPT 風格的連接器取得檔案的解碼內容與中繼資料 |
 
 > **說明：** 部分工具是聚合的、基於操作的工具，單個工具透過 `method` 參數暴露多個操作。當伺服器以唯讀模式執行時（`-r` / `GITEA_READONLY`），存取為「寫入」的工具會被隱藏；可透過 `-S` / `--scope`（`GITEA_SCOPES`）依範圍過濾，或透過 `-O` / `--tools`（`GITEA_TOOLS`）依工具名稱過濾對外暴露的工具集合。
 

go.mod

@@ -5,7 +5,7 @@ go 1.26.0
 toolchain go1.26.6
 
 require (
-	gitea.dev/sdk v1.2.0
+	gitea.dev/sdk v1.2.1-0.20260822201514-76e7eafcee4b
 	github.com/modelcontextprotocol/go-sdk v1.7.0
 	go.uber.org/zap v1.28.0
 	go.uber.org/zap/exp v0.3.0

go.sum

@@ -1,5 +1,5 @@
-gitea.dev/sdk v1.2.0 h1:avRtJl/nKCGispgSalo9czoZM9Rto1awnE0caNAoXGo=
-gitea.dev/sdk v1.2.0/go.mod h1:rfh5oNdIK24cbCREwIn1tqWKQW+IICXFGWJyebuOAOE=
+gitea.dev/sdk v1.2.1-0.20260822201514-76e7eafcee4b h1:Ub2tRd59s7zBxalMyaNyuwl2JA9/ZV4svGVbmV7itcU=
+gitea.dev/sdk v1.2.1-0.20260822201514-76e7eafcee4b/go.mod h1:McaA1Vd+POnguz48vHfgD9jWmeInt10eH/bKaCIVGDA=
 github.com/42wim/httpsig v1.2.4 h1:mI5bH0nm4xn7K18fo1K3okNDRq8CCJ0KbBYWyA6r8lU=
 github.com/42wim/httpsig v1.2.4/go.mod h1:yKsYfSyTBEohkPik224QPFylmzEBtda/kjyIAJjh3ps=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

operation/connector/connector.go

@@ -1,159 +0,0 @@
-// Package connector provides the "search" and "fetch" tools expected by
-// ChatGPT-style MCP connectors (https://platform.openai.com/docs/mcp), on
-// top of the same Gitea SDK calls the search and file domains already use.
-package connector
-
-import (
-	"context"
-	"encoding/base64"
-	"fmt"
-
-	"gitea.com/gitea/gitea-mcp/pkg/annotation"
-	"gitea.com/gitea/gitea-mcp/pkg/gitea"
-	"gitea.com/gitea/gitea-mcp/pkg/params"
-	"gitea.com/gitea/gitea-mcp/pkg/to"
-	"gitea.com/gitea/gitea-mcp/pkg/tool"
-
-	gitea_sdk "gitea.dev/sdk"
-	"github.com/modelcontextprotocol/go-sdk/mcp"
-)
-
-// Tool holds the connector tools (scope "connector"): search and fetch.
-var Tool = tool.New("connector")
-
-const (
-	SearchToolName = "search"
-	FetchToolName  = "fetch"
-)
-
-var (
-	SearchTool = tool.NewDefinition(
-		SearchToolName,
-		"Search Gitea repositories by keyword. Returns concise entries suitable for ChatGPT-style connectors.",
-		annotation.ReadOnly("Search"),
-		tool.String("query", tool.Required(), tool.Description("search keyword")),
-		tool.String("owner", tool.Description("filter results to repositories owned by this user")),
-		tool.String("org", tool.Description("filter results to repositories owned by this organization")),
-		tool.Number("page", tool.Description(params.PageDesc), tool.Default(1)),
-		tool.Number("per_page", tool.Description(params.PaginationDesc), tool.Default(30)),
-	)
-
-	FetchTool = tool.NewDefinition(
-		FetchToolName,
-		"Fetch a file's decoded content and metadata from a Gitea repository. Suitable for ChatGPT-style connectors.",
-		annotation.ReadOnly("Fetch"),
-		tool.String("owner", tool.Required(), tool.Description(params.OwnerDesc)),
-		tool.String("repo", tool.Required(), tool.Description(params.RepoDesc)),
-		tool.String("path", tool.Required()),
-		tool.String("ref", tool.Description("branch, tag, or commit SHA")),
-	)
-)
-
-func init() {
-	Tool.RegisterRead(tool.ServerTool{
-		Tool:    SearchTool,
-		Handler: SearchFn,
-	})
-	Tool.RegisterRead(tool.ServerTool{
-		Tool:    FetchTool,
-		Handler: FetchFn,
-	})
-}
-
-// SearchFn searches Gitea repositories by keyword, optionally scoped to an
-// owner or organization, and returns concise entries.
-func SearchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	query, err := params.GetString(args, "query")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-
-	ownerName := params.GetOptionalString(args, "owner", "")
-	if ownerName == "" {
-		ownerName = params.GetOptionalString(args, "org", "")
-	}
-	var ownerID int64
-	if ownerName != "" {
-		owner, _, err := client.Users.GetUserInfo(ctx, ownerName)
-		if err != nil {
-			return to.ErrorResult(fmt.Errorf("resolve owner %q err: %v", ownerName, err))
-		}
-		ownerID = owner.ID
-	}
-
-	page, pageSize := params.GetPagination(args, 30)
-	opt := gitea_sdk.SearchRepoOptions{
-		Keyword: query,
-		OwnerID: ownerID,
-		ListOptions: gitea_sdk.ListOptions{
-			Page:     page,
-			PageSize: pageSize,
-		},
-	}
-	repos, _, err := client.Repositories.SearchRepos(ctx, opt)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("search repos err: %v", err))
-	}
-	return to.TextResult(slimSearchResults(repos))
-}
-
-// FetchFn fetches a file's content and decodes it, returning the decoded
-// content alongside path, sha, size, and encoding metadata.
-func FetchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	filePath, err := params.GetString(args, "path")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	ref := params.GetOptionalString(args, "ref", "")
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	content, _, err := client.Repositories.GetContents(ctx, owner, repo, ref, filePath)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get file err: %v", err))
-	}
-
-	decoded, err := decodeContent(content)
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	return to.TextResult(map[string]any{
-		"path":     content.Path,
-		"sha":      content.SHA,
-		"size":     content.Size,
-		"encoding": stringOrEmpty(content.Encoding),
-		"content":  decoded,
-	})
-}
-
-func decodeContent(c *gitea_sdk.ContentsResponse) (string, error) {
-	if c.Content == nil {
-		return "", nil
-	}
-	raw, err := base64.StdEncoding.DecodeString(*c.Content)
-	if err != nil {
-		return "", fmt.Errorf("decode base64 content err: %v", err)
-	}
-	return string(raw), nil
-}
-
-func stringOrEmpty(s *string) string {
-	if s == nil {
-		return ""
-	}
-	return *s
-}

operation/connector/connector_test.go

@@ -1,155 +0,0 @@
-package connector
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"gitea.com/gitea/gitea-mcp/pkg/flag"
-
-	"github.com/modelcontextprotocol/go-sdk/mcp"
-)
-
-func withTestServer(t *testing.T, handler http.HandlerFunc) {
-	t.Helper()
-	server := httptest.NewServer(handler)
-	t.Cleanup(server.Close)
-
-	origHost, origToken := flag.Host, flag.Token
-	flag.Host, flag.Token = server.URL, ""
-	t.Cleanup(func() { flag.Host, flag.Token = origHost, origToken })
-}
-
-func resultText(t *testing.T, result *mcp.CallToolResult) string {
-	t.Helper()
-	text, ok := result.Content[0].(*mcp.TextContent)
-	if !ok {
-		t.Fatalf("result content = %T, want *mcp.TextContent", result.Content[0])
-	}
-	return text.Text
-}
-
-func TestSearchFnReturnsConciseRepoEntries(t *testing.T) {
-	withTestServer(t, func(w http.ResponseWriter, r *http.Request) {
-		if strings.HasSuffix(r.URL.Path, "/version") {
-			_, _ = w.Write([]byte(`{"version":"1.26.0"}`))
-			return
-		}
-		if !strings.HasSuffix(r.URL.Path, "/repos/search") {
-			t.Fatalf("unexpected request path %q", r.URL.Path)
-		}
-		if q := r.URL.Query().Get("q"); q != "gitea-mcp" {
-			t.Fatalf("query q = %q, want gitea-mcp", q)
-		}
-		_, _ = w.Write([]byte(`{"data":[{"id":42,"name":"gitea-mcp","full_name":"gitea/gitea-mcp","html_url":"https://gitea.com/gitea/gitea-mcp","description":"MCP server"}]}`))
-	})
-
-	result, err := SearchFn(context.Background(), map[string]any{"query": "gitea-mcp"})
-	if err != nil {
-		t.Fatalf("SearchFn() error = %v", err)
-	}
-
-	var entries []map[string]any
-	if err := json.Unmarshal([]byte(resultText(t, result)), &entries); err != nil {
-		t.Fatalf("unmarshal result: %v", err)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("len(entries) = %d, want 1", len(entries))
-	}
-	entry := entries[0]
-	if entry["id"] != float64(42) {
-		t.Errorf("id = %v, want 42", entry["id"])
-	}
-	if entry["name"] != "gitea-mcp" {
-		t.Errorf("name = %v, want gitea-mcp", entry["name"])
-	}
-	if entry["url"] != "https://gitea.com/gitea/gitea-mcp" {
-		t.Errorf("url = %v, want the repo html_url", entry["url"])
-	}
-	if entry["html_url"] != "https://gitea.com/gitea/gitea-mcp" {
-		t.Errorf("html_url = %v, want the repo html_url", entry["html_url"])
-	}
-}
-
-func TestSearchFnRequiresQuery(t *testing.T) {
-	result, err := SearchFn(context.Background(), map[string]any{})
-	if err != nil {
-		t.Fatalf("SearchFn() error = %v", err)
-	}
-	if !result.IsError {
-		t.Fatal("SearchFn() result.IsError = false, want true for a missing query")
-	}
-}
-
-func TestSearchFnResolvesOwnerFilterToOwnerID(t *testing.T) {
-	withTestServer(t, func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.HasSuffix(r.URL.Path, "/version"):
-			_, _ = w.Write([]byte(`{"version":"1.26.0"}`))
-		case strings.HasSuffix(r.URL.Path, "/users/octo"):
-			_, _ = w.Write([]byte(`{"id":7,"login":"octo"}`))
-		case strings.HasSuffix(r.URL.Path, "/repos/search"):
-			if uid := r.URL.Query().Get("uid"); uid != "7" {
-				t.Fatalf("uid = %q, want 7", uid)
-			}
-			_, _ = w.Write([]byte(`{"data":[]}`))
-		default:
-			t.Fatalf("unexpected request path %q", r.URL.Path)
-		}
-	})
-
-	if _, err := SearchFn(context.Background(), map[string]any{"query": "demo", "owner": "octo"}); err != nil {
-		t.Fatalf("SearchFn() error = %v", err)
-	}
-}
-
-func TestFetchFnReturnsDecodedContentAndMetadata(t *testing.T) {
-	withTestServer(t, func(w http.ResponseWriter, r *http.Request) {
-		if !strings.Contains(r.URL.Path, "/contents/") {
-			t.Fatalf("unexpected request path %q", r.URL.Path)
-		}
-		_, _ = w.Write([]byte(`{"name":"README.md","path":"README.md","sha":"abc123","type":"file","size":11,"encoding":"base64","content":"aGVsbG8gd29ybGQ="}`))
-	})
-
-	result, err := FetchFn(context.Background(), map[string]any{
-		"owner": "octo",
-		"repo":  "demo",
-		"path":  "README.md",
-	})
-	if err != nil {
-		t.Fatalf("FetchFn() error = %v", err)
-	}
-
-	var got map[string]any
-	if err := json.Unmarshal([]byte(resultText(t, result)), &got); err != nil {
-		t.Fatalf("unmarshal result: %v", err)
-	}
-	if got["content"] != "hello world" {
-		t.Errorf("content = %v, want decoded %q", got["content"], "hello world")
-	}
-	if got["path"] != "README.md" {
-		t.Errorf("path = %v, want README.md", got["path"])
-	}
-	if got["sha"] != "abc123" {
-		t.Errorf("sha = %v, want abc123", got["sha"])
-	}
-	if got["size"] != float64(11) {
-		t.Errorf("size = %v, want 11", got["size"])
-	}
-	if got["encoding"] != "base64" {
-		t.Errorf("encoding = %v, want base64", got["encoding"])
-	}
-}
-
-func TestFetchFnRequiresPath(t *testing.T) {
-	result, err := FetchFn(context.Background(), map[string]any{"owner": "octo", "repo": "demo"})
-	if err != nil {
-		t.Fatalf("FetchFn() error = %v", err)
-	}
-	if !result.IsError {
-		t.Fatal("FetchFn() result.IsError = false, want true for a missing path")
-	}
-}

operation/connector/slim.go

@@ -1,29 +0,0 @@
-package connector
-
-import (
-	gitea_sdk "gitea.dev/sdk"
-)
-
-// slimSearchResult is the concise entry shape ChatGPT-style connectors
-// expect from search: an id, a title, and a url to fetch it by.
-func slimSearchResult(r *gitea_sdk.Repository) map[string]any {
-	if r == nil {
-		return nil
-	}
-	return map[string]any{
-		"id":          r.ID,
-		"name":        r.Name,
-		"full_name":   r.FullName,
-		"description": r.Description,
-		"url":         r.HTMLURL,
-		"html_url":    r.HTMLURL,
-	}
-}
-
-func slimSearchResults(repos []*gitea_sdk.Repository) []map[string]any {
-	out := make([]map[string]any, 0, len(repos))
-	for _, r := range repos {
-		out = append(out, slimSearchResult(r))
-	}
-	return out
-}

operation/issue/slim.go

@@ -11,6 +11,7 @@ func slimIssue(i *gitea_sdk.Issue) map[string]any {
 		return nil
 	}
 	m := map[string]any{
+		"id":         i.ID,
 		"number":     i.Index,
 		"title":      i.Title,
 		"body":       i.Body,
@@ -51,6 +52,7 @@ func slimIssues(issues []*gitea_sdk.Issue) []map[string]any {
 			continue
 		}
 		m := map[string]any{
+			"id":         i.ID,
 			"number":     i.Index,
 			"title":      i.Title,
 			"state":      i.State,

operation/issue/slim_test.go

@@ -8,6 +8,7 @@ import (
 
 func TestSlimIssue(t *testing.T) {
 	i := &gitea_sdk.Issue{
+		ID:      99,
 		Index:   42,
 		Title:   "Bug report",
 		Body:    "Something is broken",
@@ -24,6 +25,9 @@ func TestSlimIssue(t *testing.T) {
 
 	m := slimIssue(i)
 
+	if m["id"] != int64(99) {
+		t.Errorf("expected id 99, got %v", m["id"])
+	}
 	if m["number"] != int64(42) {
 		t.Errorf("expected number 42, got %v", m["number"])
 	}

operation/operation.go

@@ -14,12 +14,12 @@ import (
 	"time"
 
 	"gitea.com/gitea/gitea-mcp/operation/actions"
-	"gitea.com/gitea/gitea-mcp/operation/connector"
 	"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/notification"
 	"gitea.com/gitea/gitea-mcp/operation/packages"
+	"gitea.com/gitea/gitea-mcp/operation/project"
 	"gitea.com/gitea/gitea-mcp/operation/pull"
 	"gitea.com/gitea/gitea-mcp/operation/repo"
 	"gitea.com/gitea/gitea-mcp/operation/search"
@@ -48,7 +48,7 @@ var (
 	domainTools = []*tool.Tool{
 		user.Tool, actions.Tool, repo.Tool, notification.Tool, issue.Tool,
 		label.Tool, milestone.Tool, packages.Tool, pull.Tool, search.Tool,
-		version.Tool, wiki.Tool, timetracking.Tool, connector.Tool,
+		project.Tool, version.Tool, wiki.Tool, timetracking.Tool,
 		repo.FileTool, repo.BranchTool, repo.TagTool, repo.CommitTool, repo.ReleaseTool,
 	}
 )

operation/project/project.go

@@ -0,0 +1,608 @@
+package project
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"gitea.com/gitea/gitea-mcp/pkg/annotation"
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/params"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+	"gitea.com/gitea/gitea-mcp/pkg/tool"
+
+	gitea_sdk "gitea.dev/sdk"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+var Tool = tool.New("project")
+
+const (
+	ProjectReadToolName  = "project_read"
+	ProjectWriteToolName = "project_write"
+)
+
+var (
+	ProjectReadTool = tool.NewDefinition(
+		ProjectReadToolName,
+		"Read projects: list projects, get a project, list columns, get a column, or list issues in a column.",
+		annotation.ReadOnly("Read projects"),
+		tool.String("method", tool.Required(), tool.Enum("list", "get", "list_columns", "get_column", "list_column_issues")),
+		tool.String("scope", tool.Required(), tool.Enum("repo", "org", "user", "current_user")),
+		tool.String("owner", tool.Description("repo owner for 'repo' scope, org name for 'org' scope, username for 'user' scope")),
+		tool.String("repo", tool.Description("repo name for 'repo' scope")),
+		tool.String("state", tool.Default("all"), tool.Enum("open", "closed", "all")),
+		tool.Number("project_id", tool.Description("project ID for 'get' and column methods")),
+		tool.Number("column_id", tool.Description("column ID for 'get_column' and 'list_column_issues'")),
+		tool.Number("page", tool.Description(params.PageDesc), tool.Default(1), tool.Minimum(1)),
+		tool.Number("per_page", tool.Description(params.PaginationDesc), tool.Default(30), tool.Minimum(1)),
+	)
+
+	ProjectWriteTool = tool.NewDefinition(
+		ProjectWriteToolName,
+		"Write projects: create, update, or delete projects and columns; reorder columns; add, remove, or move issues.",
+		annotation.Destructive("Create, update, or delete projects and project columns"),
+		tool.String("method", tool.Required(), tool.Enum("create", "update", "delete", "create_column", "update_column", "delete_column", "set_default_column", "move_columns", "add_issue", "remove_issue", "move_issue")),
+		tool.String("scope", tool.Required(), tool.Enum("repo", "org", "current_user")),
+		tool.String("owner", tool.Description("repo owner for 'repo' scope, org name for 'org' scope")),
+		tool.String("repo", tool.Description("repo name for 'repo' scope")),
+		tool.Number("project_id", tool.Description("project ID (required except for 'create')")),
+		tool.Number("column_id", tool.Description("column ID (required for column and issue methods)")),
+		tool.Number("issue_id", tool.Description("global issue ID (required for 'add_issue', 'remove_issue', and 'move_issue')")),
+		tool.String("title", tool.Description("for 'create', 'update', 'create_column', and 'update_column'")),
+		tool.String("description", tool.Description("for 'create' and 'update'")),
+		tool.String("template_type", tool.Enum("none", "basic_kanban", "bug_triage")),
+		tool.String("card_type", tool.Enum("text_only", "images_and_text")),
+		tool.String("state", tool.Enum("open", "closed")),
+		tool.String("color", tool.Description("6-digit hex column color, e.g. #FF0000")),
+		tool.Number("sorting", tool.Description("position for 'update_column' and 'move_issue'")),
+		tool.Array("column_ids", tool.Description("ordered column IDs for 'move_columns'"), tool.Items(map[string]any{"type": "number"})),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(tool.ServerTool{
+		Tool:    ProjectReadTool,
+		Handler: projectReadFn,
+	})
+	Tool.RegisterWrite(tool.ServerTool{
+		Tool:    ProjectWriteTool,
+		Handler: projectWriteFn,
+	})
+}
+
+type projectScopeInfo struct {
+	scope gitea_sdk.ProjectScope
+	kind  string
+}
+
+func getProjectScope(args map[string]any, writable bool) (projectScopeInfo, error) {
+	scopeName := params.GetOptionalString(args, "scope", "")
+	switch scopeName {
+	case "repo":
+		owner, err := params.GetString(args, "owner")
+		if err != nil {
+			return projectScopeInfo{}, err
+		}
+		repo, err := params.GetString(args, "repo")
+		if err != nil {
+			return projectScopeInfo{}, err
+		}
+		return projectScopeInfo{scope: gitea_sdk.RepoProjectScope(owner, repo), kind: "repo"}, nil
+	case "org":
+		owner, err := params.GetString(args, "owner")
+		if err != nil {
+			return projectScopeInfo{}, err
+		}
+		return projectScopeInfo{scope: gitea_sdk.OrgProjectScope(owner), kind: "org"}, nil
+	case "user":
+		owner, err := params.GetString(args, "owner")
+		if err != nil {
+			return projectScopeInfo{}, err
+		}
+		if writable {
+			return projectScopeInfo{}, errors.New("scope 'user' only supports listing projects")
+		}
+		return projectScopeInfo{scope: gitea_sdk.UserProjectScope(owner), kind: "user"}, nil
+	case "current_user":
+		return projectScopeInfo{scope: gitea_sdk.CurrentUserProjectScope(), kind: "current_user"}, nil
+	default:
+		if scopeName == "" {
+			return projectScopeInfo{}, errors.New("scope is required")
+		}
+		return projectScopeInfo{}, fmt.Errorf("unknown scope: %s", scopeName)
+	}
+}
+
+func projectReadFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	method, err := params.GetString(args, "method")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	switch method {
+	case "list":
+		return listProjectsFn(ctx, args)
+	case "get":
+		return getProjectFn(ctx, args)
+	case "list_columns":
+		return listProjectColumnsFn(ctx, args)
+	case "get_column":
+		return getProjectColumnFn(ctx, args)
+	case "list_column_issues":
+		return listProjectColumnIssuesFn(ctx, args)
+	default:
+		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
+	}
+}
+
+func projectWriteFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	method, err := params.GetString(args, "method")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	switch method {
+	case "create":
+		return createProjectFn(ctx, args)
+	case "update":
+		return updateProjectFn(ctx, args)
+	case "delete":
+		return deleteProjectFn(ctx, args)
+	case "create_column":
+		return createProjectColumnFn(ctx, args)
+	case "update_column":
+		return updateProjectColumnFn(ctx, args)
+	case "delete_column":
+		return deleteProjectColumnFn(ctx, args)
+	case "set_default_column":
+		return setDefaultProjectColumnFn(ctx, args)
+	case "move_columns":
+		return moveProjectColumnsFn(ctx, args)
+	case "add_issue":
+		return addIssueToProjectColumnFn(ctx, args)
+	case "remove_issue":
+		return removeIssueFromProjectColumnFn(ctx, args)
+	case "move_issue":
+		return moveProjectIssueFn(ctx, args)
+	default:
+		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
+	}
+}
+
+func listProjectsFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, false)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	state := params.GetOptionalString(args, "state", "all")
+	page, pageSize := params.GetPagination(args, 30)
+	opt := gitea_sdk.ListProjectsOptions{
+		State: gitea_sdk.StateType(state),
+		ListOptions: gitea_sdk.ListOptions{
+			Page:     page,
+			PageSize: pageSize,
+		},
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	projects, _, err := client.Projects.ListProjects(ctx, info.scope, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list projects err: %v", err))
+	}
+	return to.TextResult(slimProjects(projects))
+}
+
+func getProjectFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, false)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	project, _, err := client.Projects.GetProject(ctx, info.scope, projectID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get project/%d err: %v", projectID, err))
+	}
+	return to.TextResult(slimProject(project))
+}
+
+func listProjectColumnsFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, false)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	page, pageSize := params.GetPagination(args, 30)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	columns, _, err := client.Projects.ListProjectColumns(ctx, info.scope, projectID, gitea_sdk.ListOptions{
+		Page:     page,
+		PageSize: pageSize,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list project/%d/columns err: %v", projectID, err))
+	}
+	return to.TextResult(slimProjectColumns(columns))
+}
+
+func getProjectColumnFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, false)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnID, err := params.GetIndex(args, "column_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	column, _, err := client.Projects.GetProjectColumn(ctx, info.scope, projectID, columnID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get project/%d/columns/%d err: %v", projectID, columnID, err))
+	}
+	return to.TextResult(slimProjectColumn(column))
+}
+
+func listProjectColumnIssuesFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, false)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnID, err := params.GetIndex(args, "column_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	page, pageSize := params.GetPagination(args, 30)
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	issues, _, err := client.Projects.ListProjectColumnIssues(ctx, info.scope, projectID, columnID, gitea_sdk.ListOptions{
+		Page:     page,
+		PageSize: pageSize,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list project/%d/columns/%d/issues err: %v", projectID, columnID, err))
+	}
+	return to.TextResult(slimProjectIssues(issues))
+}
+
+func createProjectFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	title, err := params.GetString(args, "title")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	opt := gitea_sdk.CreateProjectOption{Title: title}
+	if description, ok := args["description"].(string); ok {
+		opt.Description = description
+	}
+	if templateType, ok := args["template_type"].(string); ok {
+		opt.TemplateType = gitea_sdk.ProjectTemplateType(templateType)
+	}
+	if cardType, ok := args["card_type"].(string); ok {
+		opt.CardType = gitea_sdk.ProjectCardType(cardType)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	project, _, err := client.Projects.CreateProject(ctx, info.scope, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create project err: %v", err))
+	}
+	return to.TextResult(slimProject(project))
+}
+
+func updateProjectFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	opt := gitea_sdk.EditProjectOption{
+		Title:       params.GetPresentStringPtr(args, "title"),
+		Description: params.GetPresentStringPtr(args, "description"),
+	}
+	if cardType, ok := args["card_type"].(string); ok {
+		value := gitea_sdk.ProjectCardType(cardType)
+		opt.CardType = &value
+	}
+	if state, ok := args["state"].(string); ok {
+		value := gitea_sdk.StateType(state)
+		opt.State = &value
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	project, _, err := client.Projects.EditProject(ctx, info.scope, projectID, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("update project/%d err: %v", projectID, err))
+	}
+	return to.TextResult(slimProject(project))
+}
+
+func deleteProjectFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.Projects.DeleteProject(ctx, info.scope, projectID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete project/%d err: %v", projectID, err))
+	}
+	return to.TextResult("Project deleted successfully")
+}
+
+func createProjectColumnFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	title, err := params.GetString(args, "title")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	opt := gitea_sdk.CreateProjectColumnOption{Title: title}
+	if color, ok := args["color"].(string); ok {
+		opt.Color = color
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	column, _, err := client.Projects.CreateProjectColumn(ctx, info.scope, projectID, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create project/%d/column err: %v", projectID, err))
+	}
+	return to.TextResult(slimProjectColumn(column))
+}
+
+func updateProjectColumnFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnID, err := params.GetIndex(args, "column_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	opt := gitea_sdk.EditProjectColumnOption{
+		Title: params.GetPresentStringPtr(args, "title"),
+		Color: params.GetPresentStringPtr(args, "color"),
+	}
+	if sorting, ok := optionalIntPtr(args, "sorting"); ok {
+		opt.Sorting = sorting
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	column, _, err := client.Projects.EditProjectColumn(ctx, info.scope, projectID, columnID, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("update project/%d/columns/%d err: %v", projectID, columnID, err))
+	}
+	return to.TextResult(slimProjectColumn(column))
+}
+
+func deleteProjectColumnFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnID, err := params.GetIndex(args, "column_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.Projects.DeleteProjectColumn(ctx, info.scope, projectID, columnID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete project/%d/columns/%d err: %v", projectID, columnID, err))
+	}
+	return to.TextResult("Project column deleted successfully")
+}
+
+func setDefaultProjectColumnFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnID, err := params.GetIndex(args, "column_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.Projects.SetDefaultProjectColumn(ctx, info.scope, projectID, columnID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("set project/%d default column/%d err: %v", projectID, columnID, err))
+	}
+	return to.TextResult("Project default column set successfully")
+}
+
+func moveProjectColumnsFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnIDs, err := params.GetInt64Slice(args, "column_ids")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.Projects.MoveProjectColumns(ctx, info.scope, projectID, gitea_sdk.MoveProjectColumnsOption{ColumnIDs: columnIDs})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("move project/%d columns err: %v", projectID, err))
+	}
+	return to.TextResult("Project columns moved successfully")
+}
+
+func addIssueToProjectColumnFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnID, err := params.GetIndex(args, "column_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	issueID, err := params.GetIndex(args, "issue_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.Projects.AddIssueToProjectColumn(ctx, info.scope, projectID, columnID, issueID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("add issue/%d to project/%d/columns/%d err: %v", issueID, projectID, columnID, err))
+	}
+	return to.TextResult("Issue added to project column successfully")
+}
+
+func removeIssueFromProjectColumnFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnID, err := params.GetIndex(args, "column_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	issueID, err := params.GetIndex(args, "issue_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.Projects.RemoveIssueFromProjectColumn(ctx, info.scope, projectID, columnID, issueID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("remove issue/%d from project/%d/columns/%d err: %v", issueID, projectID, columnID, err))
+	}
+	return to.TextResult("Issue removed from project column successfully")
+}
+
+func moveProjectIssueFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	info, err := getProjectScope(args, true)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	projectID, err := params.GetIndex(args, "project_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	issueID, err := params.GetIndex(args, "issue_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	columnID, err := params.GetIndex(args, "column_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	opt := gitea_sdk.MoveProjectIssueOption{ColumnID: columnID}
+	if sorting, ok := optionalInt64Ptr(args, "sorting"); ok {
+		opt.Sorting = sorting
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	_, err = client.Projects.MoveProjectIssue(ctx, info.scope, projectID, issueID, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("move issue/%d in project/%d err: %v", issueID, projectID, err))
+	}
+	return to.TextResult("Project issue moved successfully")
+}
+
+func optionalIntPtr(args map[string]any, key string) (*int, bool) {
+	value, ok := params.ToInt64(args[key])
+	if !ok {
+		return nil, false
+	}
+	converted := int(value)
+	return &converted, true
+}
+
+func optionalInt64Ptr(args map[string]any, key string) (*int64, bool) {
+	value, ok := params.ToInt64(args[key])
+	if !ok {
+		return nil, false
+	}
+	return &value, true
+}

operation/project/project_test.go

@@ -0,0 +1,517 @@
+package project
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"testing"
+
+	mcpContext "gitea.com/gitea/gitea-mcp/pkg/context"
+	"gitea.com/gitea/gitea-mcp/pkg/flag"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+func TestGetProjectScope(t *testing.T) {
+	tests := []struct {
+		name     string
+		args     map[string]any
+		writable bool
+		wantKind string
+		wantErr  bool
+	}{
+		{
+			name:     "repo",
+			args:     map[string]any{"scope": "repo", "owner": "octo", "repo": "demo"},
+			wantKind: "repo",
+		},
+		{
+			name:     "org",
+			args:     map[string]any{"scope": "org", "owner": "acme"},
+			wantKind: "org",
+		},
+		{
+			name:     "user read",
+			args:     map[string]any{"scope": "user", "owner": "octo"},
+			wantKind: "user",
+		},
+		{
+			name:     "user write",
+			args:     map[string]any{"scope": "user", "owner": "octo"},
+			writable: true,
+			wantErr:  true,
+		},
+		{
+			name:     "current user",
+			args:     map[string]any{"scope": "current_user"},
+			wantKind: "current_user",
+		},
+		{
+			name:    "missing scope",
+			args:    map[string]any{},
+			wantErr: true,
+		},
+		{
+			name:    "repo missing owner",
+			args:    map[string]any{"scope": "repo", "repo": "demo"},
+			wantErr: true,
+		},
+		{
+			name:    "repo missing repo",
+			args:    map[string]any{"scope": "repo", "owner": "octo"},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			info, err := getProjectScope(tt.args, tt.writable)
+			if tt.wantErr {
+				if err == nil {
+					t.Fatal("expected an error, got nil")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("getProjectScope() error = %v", err)
+			}
+			if info.kind != tt.wantKind {
+				t.Fatalf("scope kind = %q, want %q", info.kind, tt.wantKind)
+			}
+		})
+	}
+}
+
+func TestProjectReadFn(t *testing.T) {
+	const (
+		owner     = "octo"
+		repo      = "demo"
+		projectID = 10
+		columnID  = 20
+	)
+
+	var (
+		mu     sync.Mutex
+		gotReq = struct {
+			method string
+			path   string
+			query  string
+		}{}
+	)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		mu.Lock()
+		gotReq.method = r.Method
+		gotReq.path = r.URL.Path
+		gotReq.query = r.URL.RawQuery
+		mu.Unlock()
+
+		switch r.URL.Path {
+		case "/api/v1/version":
+			_, _ = w.Write([]byte(`{"version":"1.28.0"}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/projects", owner, repo):
+			_, _ = w.Write(fmt.Appendf(nil, `[{"id":%d,"title":"Board","state":"open"}]`, projectID))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d", owner, repo, projectID):
+			_, _ = w.Write(fmt.Appendf(nil, `{"id":%d,"title":"Board","state":"open"}`, projectID))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns", owner, repo, projectID):
+			_, _ = w.Write(fmt.Appendf(nil, `[{"id":%d,"title":"Todo","project_id":%d}]`, columnID, projectID))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d/issues", owner, repo, projectID, columnID):
+			_, _ = w.Write([]byte(`[{"id":5,"number":1,"title":"An issue","state":"open","html_url":"https://example.com/1","user":{"login":"octo"}}]`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d", owner, repo, projectID, columnID):
+			_, _ = w.Write(fmt.Appendf(nil, `{"id":%d,"title":"Todo","project_id":%d}`, columnID, projectID))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
+	flag.Host, flag.Token, flag.Version = server.URL, "", "test"
+	defer func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion }()
+
+	ctx := context.WithValue(context.Background(), mcpContext.TokenContextKey, "project-read-token")
+
+	tests := []struct {
+		name     string
+		args     map[string]any
+		wantPath string
+		wantID   float64
+	}{
+		{
+			name: "list",
+			args: map[string]any{
+				"method": "list",
+				"scope":  "repo",
+				"owner":  owner,
+				"repo":   repo,
+				"state":  "open",
+			},
+			wantPath: fmt.Sprintf("/api/v1/repos/%s/%s/projects", owner, repo),
+			wantID:   projectID,
+		},
+		{
+			name: "get",
+			args: map[string]any{
+				"method":     "get",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+			},
+			wantPath: fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d", owner, repo, projectID),
+			wantID:   projectID,
+		},
+		{
+			name: "list columns",
+			args: map[string]any{
+				"method":     "list_columns",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+			},
+			wantPath: fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns", owner, repo, projectID),
+			wantID:   columnID,
+		},
+		{
+			name: "get column",
+			args: map[string]any{
+				"method":     "get_column",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"column_id":  float64(columnID),
+			},
+			wantPath: fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d", owner, repo, projectID, columnID),
+			wantID:   columnID,
+		},
+		{
+			name: "list column issues",
+			args: map[string]any{
+				"method":     "list_column_issues",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"column_id":  float64(columnID),
+			},
+			wantPath: fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d/issues", owner, repo, projectID, columnID),
+			wantID:   5,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := projectReadFn(ctx, tt.args)
+			if err != nil {
+				t.Fatalf("projectReadFn() error = %v", err)
+			}
+			if result.IsError {
+				t.Fatalf("projectReadFn() returned error result: %v", result)
+			}
+
+			mu.Lock()
+			path := gotReq.path
+			query := gotReq.query
+			mu.Unlock()
+			if path != tt.wantPath {
+				t.Fatalf("request path = %q, want %q", path, tt.wantPath)
+			}
+			if tt.name == "list" && query == "" {
+				t.Fatal("expected list query parameters, got none")
+			}
+
+			if len(result.Content) == 0 {
+				t.Fatal("expected result content")
+			}
+			text, ok := result.Content[0].(*mcp.TextContent)
+			if !ok {
+				t.Fatalf("result content type = %T, want text content", result.Content[0])
+			}
+			assertFirstID(t, []byte(text.Text), tt.wantID)
+		})
+	}
+}
+
+func TestProjectWriteFn(t *testing.T) {
+	const (
+		owner     = "octo"
+		repo      = "demo"
+		projectID = 10
+		columnID  = 20
+		issueID   = 5
+	)
+
+	type request struct {
+		method string
+		path   string
+		body   map[string]any
+	}
+
+	var (
+		mu       sync.Mutex
+		requests []request
+	)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		if r.URL.Path == "/api/v1/version" {
+			_, _ = w.Write([]byte(`{"version":"1.28.0"}`))
+			return
+		}
+
+		var body map[string]any
+		if r.Body != nil && r.ContentLength > 0 {
+			_ = json.NewDecoder(r.Body).Decode(&body)
+		}
+		mu.Lock()
+		requests = append(requests, request{method: r.Method, path: r.URL.Path, body: body})
+		mu.Unlock()
+
+		switch r.Method {
+		case http.MethodGet:
+			_, _ = w.Write([]byte(`[]`))
+		case http.MethodPost, http.MethodPatch:
+			_, _ = w.Write([]byte(`{}`))
+		default:
+			w.WriteHeader(http.StatusNoContent)
+		}
+	}))
+	defer server.Close()
+
+	origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
+	flag.Host, flag.Token, flag.Version = server.URL, "", "test"
+	defer func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion }()
+
+	ctx := context.WithValue(context.Background(), mcpContext.TokenContextKey, "project-write-token")
+
+	tests := []struct {
+		name       string
+		args       map[string]any
+		wantMethod string
+		wantPath   string
+		wantBody   map[string]any
+	}{
+		{
+			name: "create",
+			args: map[string]any{
+				"method":        "create",
+				"scope":         "repo",
+				"owner":         owner,
+				"repo":          repo,
+				"title":         "Board",
+				"description":   "Project board",
+				"template_type": "basic_kanban",
+				"card_type":     "images_and_text",
+			},
+			wantMethod: http.MethodPost,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects", owner, repo),
+			wantBody:   map[string]any{"title": "Board", "description": "Project board", "template_type": "basic_kanban", "card_type": "images_and_text"},
+		},
+		{
+			name: "update",
+			args: map[string]any{
+				"method":     "update",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"title":      "Updated Board",
+				"state":      "closed",
+			},
+			wantMethod: http.MethodPatch,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d", owner, repo, projectID),
+			wantBody:   map[string]any{"title": "Updated Board", "state": "closed"},
+		},
+		{
+			name: "delete",
+			args: map[string]any{
+				"method":     "delete",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+			},
+			wantMethod: http.MethodDelete,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d", owner, repo, projectID),
+		},
+		{
+			name: "create column",
+			args: map[string]any{
+				"method":     "create_column",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"title":      "Todo",
+				"color":      "#FF0000",
+			},
+			wantMethod: http.MethodPost,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns", owner, repo, projectID),
+			wantBody:   map[string]any{"title": "Todo", "color": "#FF0000"},
+		},
+		{
+			name: "update column",
+			args: map[string]any{
+				"method":     "update_column",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"column_id":  float64(columnID),
+				"title":      "Doing",
+				"sorting":    float64(2),
+			},
+			wantMethod: http.MethodPatch,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d", owner, repo, projectID, columnID),
+			wantBody:   map[string]any{"title": "Doing", "sorting": float64(2)},
+		},
+		{
+			name: "delete column",
+			args: map[string]any{
+				"method":     "delete_column",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"column_id":  float64(columnID),
+			},
+			wantMethod: http.MethodDelete,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d", owner, repo, projectID, columnID),
+		},
+		{
+			name: "set default column",
+			args: map[string]any{
+				"method":     "set_default_column",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"column_id":  float64(columnID),
+			},
+			wantMethod: http.MethodPost,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d/default", owner, repo, projectID, columnID),
+		},
+		{
+			name: "move columns",
+			args: map[string]any{
+				"method":     "move_columns",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"column_ids": []any{float64(20), float64(21)},
+			},
+			wantMethod: http.MethodPost,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/move", owner, repo, projectID),
+			wantBody:   map[string]any{"column_ids": []any{float64(20), float64(21)}},
+		},
+		{
+			name: "add issue",
+			args: map[string]any{
+				"method":     "add_issue",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"column_id":  float64(columnID),
+				"issue_id":   float64(issueID),
+			},
+			wantMethod: http.MethodPost,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d/issues/%d", owner, repo, projectID, columnID, issueID),
+		},
+		{
+			name: "remove issue",
+			args: map[string]any{
+				"method":     "remove_issue",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"column_id":  float64(columnID),
+				"issue_id":   float64(issueID),
+			},
+			wantMethod: http.MethodDelete,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/columns/%d/issues/%d", owner, repo, projectID, columnID, issueID),
+		},
+		{
+			name: "move issue",
+			args: map[string]any{
+				"method":     "move_issue",
+				"scope":      "repo",
+				"owner":      owner,
+				"repo":       repo,
+				"project_id": float64(projectID),
+				"issue_id":   float64(issueID),
+				"column_id":  float64(columnID),
+				"sorting":    float64(3),
+			},
+			wantMethod: http.MethodPost,
+			wantPath:   fmt.Sprintf("/api/v1/repos/%s/%s/projects/%d/issues/%d/move", owner, repo, projectID, issueID),
+			wantBody:   map[string]any{"column_id": float64(columnID), "sorting": float64(3)},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := projectWriteFn(ctx, tt.args)
+			if err != nil {
+				t.Fatalf("projectWriteFn() error = %v", err)
+			}
+			if result.IsError {
+				t.Fatalf("projectWriteFn() returned error result: %v", result)
+			}
+
+			mu.Lock()
+			request := requests[len(requests)-1]
+			mu.Unlock()
+			if request.method != tt.wantMethod {
+				t.Fatalf("request method = %q, want %q", request.method, tt.wantMethod)
+			}
+			if request.path != tt.wantPath {
+				t.Fatalf("request path = %q, want %q", request.path, tt.wantPath)
+			}
+			if tt.wantBody != nil {
+				if len(request.body) != len(tt.wantBody) {
+					t.Fatalf("request body = %v, want %v", request.body, tt.wantBody)
+				}
+				for key, want := range tt.wantBody {
+					if got := request.body[key]; fmt.Sprint(got) != fmt.Sprint(want) {
+						t.Fatalf("request body[%q] = %v, want %v", key, got, want)
+					}
+				}
+			}
+		})
+	}
+}
+
+func assertFirstID(t *testing.T, data []byte, want float64) {
+	t.Helper()
+
+	if len(data) > 0 && data[0] == '[' {
+		var items []map[string]any
+		if err := json.Unmarshal(data, &items); err != nil {
+			t.Fatalf("unmarshal result text: %v", err)
+		}
+		if len(items) == 0 {
+			t.Fatal("expected at least one result item")
+		}
+		if items[0]["id"] != want {
+			t.Fatalf("first result id = %v, want %v", items[0]["id"], want)
+		}
+		return
+	}
+
+	var item map[string]any
+	if err := json.Unmarshal(data, &item); err != nil {
+		t.Fatalf("unmarshal result text: %v", err)
+	}
+	if item["id"] != want {
+		t.Fatalf("result id = %v, want %v", item["id"], want)
+	}
+}

operation/project/slim.go

@@ -0,0 +1,96 @@
+package project
+
+import (
+	"gitea.com/gitea/gitea-mcp/pkg/slim"
+
+	gitea_sdk "gitea.dev/sdk"
+)
+
+func slimProject(p *gitea_sdk.Project) map[string]any {
+	if p == nil {
+		return nil
+	}
+	return map[string]any{
+		"id":                p.ID,
+		"title":             p.Title,
+		"description":       p.Description,
+		"state":             string(p.State),
+		"type":              string(p.Type),
+		"template_type":     string(p.TemplateType),
+		"card_type":         string(p.CardType),
+		"owner_id":          p.OwnerID,
+		"repo_id":           p.RepoID,
+		"creator":           slim.UserLogin(p.Creator),
+		"num_open_issues":   p.NumOpenIssues,
+		"num_closed_issues": p.NumClosedIssues,
+		"num_issues":        p.NumIssues,
+		"html_url":          p.HTMLURL,
+		"created_at":        p.Created,
+		"updated_at":        p.Updated,
+		"closed_at":         p.Closed,
+	}
+}
+
+func slimProjects(projects []*gitea_sdk.Project) []map[string]any {
+	out := make([]map[string]any, 0, len(projects))
+	for _, p := range projects {
+		if p == nil {
+			continue
+		}
+		out = append(out, slimProject(p))
+	}
+	return out
+}
+
+func slimProjectColumn(c *gitea_sdk.ProjectColumn) map[string]any {
+	if c == nil {
+		return nil
+	}
+	return map[string]any{
+		"id":         c.ID,
+		"title":      c.Title,
+		"default":    c.Default,
+		"sorting":    c.Sorting,
+		"color":      c.Color,
+		"project_id": c.ProjectID,
+		"creator":    slim.UserLogin(c.Creator),
+		"created_at": c.Created,
+		"updated_at": c.Updated,
+	}
+}
+
+func slimProjectColumns(columns []*gitea_sdk.ProjectColumn) []map[string]any {
+	out := make([]map[string]any, 0, len(columns))
+	for _, c := range columns {
+		if c == nil {
+			continue
+		}
+		out = append(out, slimProjectColumn(c))
+	}
+	return out
+}
+
+func slimProjectIssue(i *gitea_sdk.Issue) map[string]any {
+	if i == nil {
+		return nil
+	}
+	return map[string]any{
+		"id":       i.ID,
+		"number":   i.Index,
+		"title":    i.Title,
+		"state":    string(i.State),
+		"html_url": i.HTMLURL,
+		"user":     slim.UserLogin(i.Poster),
+	}
+}
+
+func slimProjectIssues(issues []*gitea_sdk.Issue) []map[string]any {
+	out := make([]map[string]any, 0, len(issues))
+	for _, i := range issues {
+		if i == nil {
+			continue
+		}
+		out = append(out, slimProjectIssue(i))
+	}
+	return out
+}