feat(gitea): add gitea-files skill

Covers get_file_contents, get_dir_contents, get_repository_tree,
create_or_update_file, delete_file — all verified working with the
current write:issue/write:repository token scope.

plugins/gitea/skills/gitea-files/README.md

@@ -0,0 +1,23 @@
+# gitea-files
+
+Read and write individual files and directory/repository trees in a Gitea repository via the Gitea MCP server.
+
+## What it does
+
+This skill handles file-domain operations within the Gitea integration suite: reading a single file's contents, listing one directory level, walking a full repository tree (optionally recursive), creating or updating a file, and deleting a file. It owns the SHA-based optimistic-concurrency pattern that Gitea requires for file writes — the domain's sharpest gotcha — and defers branch creation, commit history, and pull request mechanics to `gitea-branches` and `gitea-prs`.
+
+## Usage
+
+```
+/gitea-files
+```
+
+Describe the file task: read a file or directory, walk a tree, create/update a file, or delete a file. Provide `owner`/`repo`/branch (or ask the user if not given) — this skill does not resolve them from a git remote itself.
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `SKILL.md` | Skill instructions for agents |
+| `references/examples.md` | Canonical call sequences: branch + file + PR, recovering a missing SHA before an update, deleting a file |
+| `references/sources.md` | Research sources backing the SHA/concurrency and direct-commit-vs-PR guidance |

plugins/gitea/skills/gitea-files/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: gitea-files
+
+description: >
+  Use when reading or writing individual files or directory trees in a Gitea repository via the
+  Gitea MCP server: reading a file's contents, listing a directory, walking a full repository
+  tree, creating a new file, updating an existing file, or deleting a file. Triggers on "read this
+  file from the repo", "what's in this directory", "show me the repo tree", "create/update a file
+  in Gitea", "commit this file to the branch", "delete this file from the repo" — even when the
+  user doesn't say "Gitea" explicitly, as long as the target is a Gitea-hosted repository. Do not
+  use for local filesystem file operations (use Read/Write/Edit), for branch or commit history
+  (use gitea-branches), or for opening a pull request around a file change (use gitea-prs after
+  the file write completes here).
+
+compatibility: Requires the Gitea MCP server configured with a token scoped to at least
+  write:repository. Tested with a token holding write:issue + write:repository; write:issue
+  is not actually required for any of this domain's five tools.
+
+metadata:
+  category: gitea
+  source_keys:
+    - gitea-mcp-repo
+    - gitea-mcp-slim-go
+    - context7-websites-gitea
+
+allowed-tools: mcp__gitea__get_file_contents mcp__gitea__get_dir_contents mcp__gitea__get_repository_tree mcp__gitea__create_or_update_file mcp__gitea__delete_file
+---
+
+## Gotchas
+
+- **SHA is the concurrency token for every write — and it lives at the top level of `get_file_contents`'s response, not nested under `content`.** `create_or_update_file` without `sha` is always treated as a *create*: if the path already exists, Gitea returns HTTP 409. `delete_file` has no optional path at all — omitting `sha` returns HTTP 422. The safe sequence for any update or delete is always: call `get_file_contents` first, read the top-level `sha` field, then pass that exact value to the write call. Never guess or reuse a stale SHA — a mismatched SHA is rejected the same as a missing one.
+- **`get_dir_contents` and `get_repository_tree` are not SHA sources for a specific file's write.** `get_dir_contents` entries carry no `sha` at all. `get_repository_tree` entries do carry a `sha` (a blob/tree hash), but fetching it means an extra round trip with no content — `get_file_contents` is the canonical path since it returns the decoded content and the write-ready `sha` in one call.
+- **`owner` and `repo` are always caller-supplied inputs, never resolved here.** This skill doesn't infer them from a git remote. If invoked directly by a human, ask for them if not stated. If invoked by `gitea-workflow` or an orchestrating agent, expect them to already be resolved and passed in.
+- **Direct commits to a branch are a first-class action, not a workaround.** Gitea's own web UI defaults to editing files directly against a branch — `create_or_update_file`/`delete_file` used that way is normal, not an API escape hatch to avoid. The SHA-currency requirement above is the actual risk to manage, not the act of committing directly.
+- **`ref` (reads) vs. `branch_name` (writes) are different parameters for the same concept.** `get_file_contents`, `get_dir_contents`, and `get_repository_tree` (as `tree_sha`) all accept a branch name, tag, or commit SHA to select what to read. `create_or_update_file` and `delete_file` instead take `branch_name` — the branch the commit lands on. Don't conflate the two when chaining a read into a write.
+- **Content is base64.** `create_or_update_file`'s `content` parameter is base64-encoded file content, not raw text — encode before calling. `get_file_contents`'s response content is likewise base64-encoded (decode after reading), unless `withLines: true` is passed for a numbered-line view.
+
+## Reading
+
+- **Single file:** `get_file_contents(owner, repo, ref, path)`. Pass `withLines: true` only when you need line numbers for referencing specific lines (e.g. quoting a snippet back to the user); omit it for a normal content fetch.
+- **One directory level:** `get_dir_contents(owner, repo, ref, path)` — returns immediate entries only (name, path, type, size), no recursion, no SHA, no content.
+- **Whole tree:** `get_repository_tree(owner, repo, tree_sha, recursive)` — `tree_sha` accepts a SHA, branch, or tag name despite the name. Set `recursive: true` to walk subdirectories in one call. Response includes `truncated: true` when a page doesn't hold every entry — page through with `page`/`per_page` (default `page: 1`, `per_page: 30`) until you get fewer results than `per_page`.
+
+## Writing
+
+- **Creating a new file:** call `create_or_update_file(owner, repo, path, content, message, branch_name)` with `sha` omitted entirely.
+- **Updating an existing file:** call `get_file_contents(owner, repo, ref: branch_name, path)` first, take the top-level `sha`, then call `create_or_update_file(..., sha: <that value>)`.
+- **Deleting a file:** call `get_file_contents` first the same way, then `delete_file(owner, repo, path, message, branch_name, sha: <that value>)` — `sha` is required, no create-style fallback exists.
+- **Creating a new branch as part of the write:** pass `new_branch_name` on `create_or_update_file` to branch off before the commit lands, instead of calling a separate branch-creation step.
+
+If the change needs review before merging, or targets a protected branch, hand off to `gitea-prs` after the write lands here to open the pull request — this skill's scope ends at the commit.
+
+If you need the full multi-call sequence rather than the single-call summary above — e.g. branching off as part of a file push ahead of opening a PR, or recovering a SHA you didn't capture earlier — read `references/examples.md`.

plugins/gitea/skills/gitea-files/references/examples.md

@@ -0,0 +1,65 @@
+---
+source_keys:
+  - gitea-mcp-repo
+  - gitea-mcp-slim-go
+---
+
+# Canonical call sequences
+
+## Push a file to a new branch, then open a PR
+
+```
+1. get_repository_tree or get_file_contents on the base branch — only needed if the
+   new file is actually replacing an existing one; skip for a brand-new path.
+
+2. create_or_update_file
+     owner, repo
+     path: "docs/example.md"
+     content: "<base64-encoded content>"
+     message: "docs: add example"
+     branch_name: "main"
+     new_branch_name: "feat/add-example"   ← branches off before the commit lands
+     (sha omitted — this is a new file)
+
+3. Hand off to gitea-prs to open a PR from "feat/add-example" into "main".
+```
+
+`new_branch_name` on `create_or_update_file` replaces a separate branch-creation call — the branch is created and the commit lands on it in one step.
+
+## Update a file when you don't already have its SHA
+
+SHA is mandatory for updates. If it wasn't captured earlier in the conversation:
+
+```
+1. get_file_contents
+     owner, repo
+     ref: "main"
+     path: "docs/example.md"
+   → read the top-level `sha` field (not content.sha)
+
+2. create_or_update_file
+     owner, repo
+     path: "docs/example.md"
+     content: "<new base64-encoded content>"
+     message: "docs: update example"
+     branch_name: "main"
+     sha: "<sha from step 1>"
+```
+
+Do not guess or omit the SHA — the write either fails (409 on create-path fallback) or is rejected outright.
+
+## Delete a file
+
+Same SHA-first pattern, no fallback path:
+
+```
+1. get_file_contents  owner, repo, ref: "main", path: "docs/old-example.md"
+   → read the top-level `sha` field
+
+2. delete_file
+     owner, repo
+     path: "docs/old-example.md"
+     message: "docs: remove old example"
+     branch_name: "main"
+     sha: "<sha from step 1>"
+```

plugins/gitea/skills/gitea-files/references/sources.md

@@ -0,0 +1,36 @@
+# Sources
+
+## gitea-mcp-repo
+
+**Description:** Official gitea-mcp repository (v1.3.0); operation/*.go source files documenting all 55 MCP tools, their parameters, and CLI flags.
+
+**Source:** https://gitea.com/gitea/gitea-mcp
+
+- **Research doc:** plugins/gitea/docs/research/docs/gitea/sources.md
+
+**Contributing files:**
+- SKILL.md (Gotchas, Reading, Writing — tool parameters and SHA/concurrency behavior, cross-checked live against the deployed MCP tool schemas via ToolSearch)
+- references/examples.md (canonical call sequences)
+
+## gitea-mcp-slim-go
+
+**Description:** Slim response shape structs from gitea-mcp source; defines exactly which fields the MCP server returns for files (top-level `sha`, no nested `content.sha`) and directory/tree entries.
+
+**Source:** https://gitea.com/gitea/gitea-mcp/raw/branch/main/operation/repo/slim.go
+
+- **Research doc:** plugins/gitea/docs/research/docs/gitea/sources.md
+
+**Contributing files:**
+- SKILL.md (Gotchas — top-level `sha` field location, `get_dir_contents`/`get_repository_tree` not being usable SHA sources for a file write)
+- references/examples.md (SHA-first update/delete sequences)
+
+## context7-websites-gitea
+
+**Description:** Official Gitea docs mirror on Context7 (docs.gitea.com content) — confirms direct-commit file editing through the web UI is a first-class, expected workflow rather than an API-only escape hatch.
+
+**Source:** context7:/websites/gitea
+
+- **Research doc:** plugins/gitea/docs/research/docs/gitea/sources.md
+
+**Contributing files:**
+- SKILL.md (Gotchas — "Direct commits to a branch are a first-class action, not a workaround")