From d5954d3d991021cef6123d8bd8454e46a63d781b Mon Sep 17 00:00:00 2001 From: Defame1297 Date: Sun, 30 Aug 2026 12:09:52 +0000 Subject: [PATCH] refactor(gitea-files): retrofit to the ADR-0020 context contract Description 787 -> 263 chars, body 922 -> 302 words, Gotchas 9 entries/69% of body -> 3/24.8%. Clears both size FAILs and both Gotchas suggestions. Deleted the second trigger register outright -- ~300 chars re-quoting the same six verbs as user phrasings, which ADR-0020 names this skill for specifically. Split the body on the read/write boundary: one invocation cannot both read and write, so a dispatch table is mandatory. Six operations collapse into two flow files rather than six -- create/update/delete share one tool pair and one SHA-first lifecycle whose preamble would otherwise be triplicated, and the three read tools share ref selection plus a 'neither listing is a SHA source' comparison that only exists between them. references/examples.md removed; all eight of its content blocks and all nine named parameters carry into references/writing.md, verified against git HEAD. Two deltas are corrections: the repo tree is now ruled out as a SHA source, and reusing a SHA captured earlier in the conversation is now forbidden. Four Gotchas relocated to the flow file that needs them; two promoted to gates (SHA-as-concurrency-token opens writing.md; owner/repo became ## Inputs). Refs #99 --- .../gitea/.apm/skills/gitea-files/README.md | 3 +- .../gitea/.apm/skills/gitea-files/SKILL.md | 50 +++++------- .../skills/gitea-files/references/examples.md | 65 ---------------- .../skills/gitea-files/references/reading.md | 46 +++++++++++ .../skills/gitea-files/references/sources.md | 14 ++-- .../skills/gitea-files/references/writing.md | 76 +++++++++++++++++++ 6 files changed, 153 insertions(+), 101 deletions(-) delete mode 100644 plugins/gitea/.apm/skills/gitea-files/references/examples.md create mode 100644 plugins/gitea/.apm/skills/gitea-files/references/reading.md create mode 100644 plugins/gitea/.apm/skills/gitea-files/references/writing.md diff --git a/plugins/gitea/.apm/skills/gitea-files/README.md b/plugins/gitea/.apm/skills/gitea-files/README.md index 52f560d..333e899 100644 --- a/plugins/gitea/.apm/skills/gitea-files/README.md +++ b/plugins/gitea/.apm/skills/gitea-files/README.md @@ -19,5 +19,6 @@ Describe the file task: read a file or directory, walk a tree, create/update a f | 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/reading.md` | Loaded for the read flow: the three read tools, `ref`/`tree_sha` selection, tree pagination, and why a listing is not a SHA source | +| `references/writing.md` | Loaded for the write flow: the SHA-first create/update/delete sequences, `new_branch_name`, the worked branch + file + PR sequence, and failed-write triage | | `references/sources.md` | Research sources backing the SHA/concurrency and direct-commit-vs-PR guidance | diff --git a/plugins/gitea/.apm/skills/gitea-files/SKILL.md b/plugins/gitea/.apm/skills/gitea-files/SKILL.md index f687f70..18e47cb 100644 --- a/plugins/gitea/.apm/skills/gitea-files/SKILL.md +++ b/plugins/gitea/.apm/skills/gitea-files/SKILL.md @@ -2,15 +2,9 @@ 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). + Use when reading or writing files in a Gitea repository rather than on the local filesystem — + read, list, walk the tree, create, update, or delete — even when the user does not say "Gitea". + Not commit history -> `gitea-branches`. Not pull requests -> `gitea-prs`. 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 @@ -28,29 +22,27 @@ allowed-tools: mcp__gitea__get_file_contents mcp__gitea__get_dir_contents mcp__g ## Gotchas -- **A 404 from any read call may actually be a 403 in disguise.** `get_file_contents`, `get_dir_contents`, and `get_repository_tree` all gate on `write:repository` scope, not just read access — some Gitea endpoints return 404 instead of 403 when the token's scope is insufficient, to avoid leaking whether the resource exists. If a read fails with 404 on a path you're confident is correct, check the token's configured scopes before concluding the file or directory doesn't exist. -- **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. -- **A write can also fail because the branch requires signed commits — a separate failure mode from a bad SHA.** `create_or_update_file` and `delete_file` create commits server-side via a bare API token call with no 2FA/PGP context. If the target branch's protection rule requires signed commits, Gitea rejects the write outright — surfaced as a generic 403 or 422, not an error naming "signed commit required," and reads against that same branch keep succeeding right up until you try to write. When a write fails without a clean 409 (missing/stale SHA) or 404 (bad path) explanation, check whether the branch's protection rule requires signed commits before assuming the SHA is wrong and retrying. -- **A large `create_or_update_file` payload can hit a reverse-proxy 413 that has nothing to do with Gitea.** `content` is base64-encoded, which inflates the payload ~33% over the raw file size; a 413 is commonly a reverse-proxy body-size limit in front of the Gitea instance, not a Gitea-side rejection. No amount of retrying, or changing the SHA, path, or branch, will fix it — it needs the proxy's config raised, which is outside this skill's or the calling agent's control. Surface that distinction to the user instead of retrying the same call. -- **`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. +- **A 404 may mean an under-scoped token, not a missing path.** Every tool here gates on `write:repository`, and Gitea masks insufficient scope as 404. Check scopes first. +- **Reads take `ref`, writes take `branch_name`.** One concept, two parameter names — chaining a read into a write drops the branch if you carry the wrong key. +- **`content` is base64 both ways.** Encode before a write, decode after a read; `withLines: true` returns numbered lines. -## Reading +## Inputs -- **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`. +`owner`, `repo` and the target branch are caller-supplied. This skill never infers them from a git remote: ask the human when they are not stated, and expect an orchestrating caller to have resolved them already. -## Writing +## Dispatch -- **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: )`. -- **Deleting a file:** call `get_file_contents` first the same way, then `delete_file(owner, repo, path, message, branch_name, sha: )` — `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. +| Condition | Flow | Reference | +|---|---|---| +| Read one file, list one directory level, or walk the repository tree | Read | `references/reading.md` | +| Create, update, or delete a file | Write | `references/writing.md` | -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 the request only inspects repository contents, read `references/reading.md` — it carries the three read tools, their pagination behaviour, and why neither a directory listing nor a tree entry supplies the SHA a write needs. -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`. +If the request creates, updates or deletes a file, read `references/writing.md` — it carries the SHA-first sequence every update and delete depends on, the worked multi-call sequence, and how to triage a write that fails. + +A request that reads and then writes runs both flows in that order: fetch the file first, then write with the SHA that call returned. + +## Handoff + +Scope ends at the commit. Gitea's own web UI edits files directly against a branch, so committing straight to a branch is the normal path rather than an escape hatch — hand off to `gitea-prs` when the change needs review before merging or the target branch is protected, not by default. diff --git a/plugins/gitea/.apm/skills/gitea-files/references/examples.md b/plugins/gitea/.apm/skills/gitea-files/references/examples.md deleted file mode 100644 index c67af6a..0000000 --- a/plugins/gitea/.apm/skills/gitea-files/references/examples.md +++ /dev/null @@ -1,65 +0,0 @@ ---- -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: "" - 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: "" - message: "docs: update example" - branch_name: "main" - sha: "" -``` - -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: "" -``` diff --git a/plugins/gitea/.apm/skills/gitea-files/references/reading.md b/plugins/gitea/.apm/skills/gitea-files/references/reading.md new file mode 100644 index 0000000..ca1847a --- /dev/null +++ b/plugins/gitea/.apm/skills/gitea-files/references/reading.md @@ -0,0 +1,46 @@ +--- +source_keys: + - gitea-mcp-repo + - gitea-mcp-slim-go +--- + +# Reading files, directories and trees + +All three read calls select what to read with `ref` — a branch name, tag, or commit SHA. On +`get_repository_tree` the same value goes in `tree_sha` despite the name. + +## Single file + +`get_file_contents(owner, repo, ref, path)`. + +The response carries the file's `sha` at the **top level**, not nested under `content`. That field +is the write-ready SHA, so capture it whenever a write may follow. Content comes back +base64-encoded — decode it. Pass `withLines: true` only when you need numbered lines to quote +specific lines back to the user; omit it for a normal content fetch. + +## One directory level + +`get_dir_contents(owner, repo, ref, path)` returns the immediate entries only — name, path, type, +size. No recursion, no content, no `sha`. + +## Whole repository tree + +`get_repository_tree(owner, repo, tree_sha, recursive)`. Set `recursive: true` to walk +subdirectories in one call. + +The response sets `truncated: true` when one page does not hold every entry. Page through with +`page`/`per_page` (defaults `1` and `30`) until a page returns fewer entries than `per_page`. + +## Neither listing is a SHA source for a write + +`get_dir_contents` entries carry no `sha` at all. `get_repository_tree` entries do carry a blob or +tree hash, but reaching it costs an extra round trip and returns no content. `get_file_contents` is +the canonical path for a write's SHA: one call returns the decoded content and the write-ready +`sha` together. + +## A 404 that is really a 403 + +These reads gate on `write:repository`, not on read access alone, and some Gitea endpoints answer +an under-scoped token with 404 instead of 403 so they do not leak whether the resource exists. A +404 on a path you are confident about is a scope problem until proven otherwise — check the token's +configured scopes before concluding the file or directory does not exist. diff --git a/plugins/gitea/.apm/skills/gitea-files/references/sources.md b/plugins/gitea/.apm/skills/gitea-files/references/sources.md index 5b15165..756778d 100644 --- a/plugins/gitea/.apm/skills/gitea-files/references/sources.md +++ b/plugins/gitea/.apm/skills/gitea-files/references/sources.md @@ -8,9 +8,10 @@ - **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) +**Contributing files:** (tool parameters and SHA/concurrency behavior cross-checked live against the deployed MCP tool schemas via ToolSearch) +- SKILL.md (Gotchas — cross-flow parameter and encoding traps; Dispatch) +- references/reading.md (read-tool parameters, `ref`/`tree_sha` selection, tree pagination) +- references/writing.md (write-tool parameters, SHA/concurrency behavior, canonical call sequences, failed-write triage) ## gitea-mcp-slim-go @@ -21,8 +22,9 @@ - **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) +- SKILL.md (Gotchas — base64 response encoding) +- references/reading.md (top-level `sha` field location, `get_dir_contents`/`get_repository_tree` not being usable SHA sources for a file write) +- references/writing.md (SHA-first update/delete sequences) ## context7-websites-gitea @@ -33,7 +35,7 @@ - **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") +- SKILL.md (Handoff — committing straight to a branch is the normal path, not an escape hatch) ## context7-gitea-tea-cli diff --git a/plugins/gitea/.apm/skills/gitea-files/references/writing.md b/plugins/gitea/.apm/skills/gitea-files/references/writing.md new file mode 100644 index 0000000..c8c96fd --- /dev/null +++ b/plugins/gitea/.apm/skills/gitea-files/references/writing.md @@ -0,0 +1,76 @@ +--- +source_keys: + - gitea-mcp-repo + - gitea-mcp-slim-go +--- + +# Creating, updating and deleting files + +`sha` is the optimistic-concurrency token for every write, and it comes from +`get_file_contents`'s **top-level** `sha` field — never from `content.sha`, a directory listing, or +a tree entry. Do not guess or reuse a stale value: a mismatched SHA is rejected exactly like a +missing one. + +`content` is base64-encoded, and the branch the commit lands on is `branch_name`, not `ref`. + +## Create a new file + +Call `create_or_update_file(owner, repo, path, content, message, branch_name)` with `sha` omitted +entirely. An omitted `sha` always means *create*, so the call returns HTTP 409 if the path already +exists. + +To branch off as part of the same write, pass `new_branch_name`: the branch is created and the +commit lands on it in one call, replacing a separate branch-creation step. + +## Update an existing file + +1. `get_file_contents(owner, repo, ref: , path)` → read the top-level `sha`. +2. `create_or_update_file(owner, repo, path, content, message, branch_name, sha: )`. + +## Delete a file + +Same SHA-first pattern, with no create-style fallback — `delete_file` without `sha` returns +HTTP 422. + +1. `get_file_contents(owner, repo, ref: , path)` → read the top-level `sha`. +2. `delete_file(owner, repo, path, message, branch_name, sha: )`. + +## Worked sequence — new file on a new branch, then a PR + +``` +1. create_or_update_file + owner, repo + path: "docs/example.md" + 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) + +2. Hand off to gitea-prs to open a PR from "feat/add-example" into "main". +``` + +Step 1 needs no preceding read: a brand-new path has no SHA. Fetch the current file first only +when the write replaces an existing one. + +## Triaging a failed write + +| Symptom | Cause | Action | +|---|---|---| +| HTTP 409 | `sha` omitted on a path that already exists | Fetch the current SHA, retry as an update | +| HTTP 422 | `sha` missing or stale | Re-fetch the SHA immediately before the write | +| 403 or 422 with no SHA explanation | Branch protection requires signed commits | Stop and report | +| HTTP 413 | Reverse-proxy body limit in front of Gitea | Report; retrying cannot fix it | +| HTTP 404 | Wrong path, or a token without `write:repository` | Verify the path, then the token's scopes | + +**Signed commits.** These writes create commits server-side from a bare API token with no 2FA or +PGP context. If the target branch's protection rule requires signed commits, Gitea rejects the +write as a generic 403 or 422 that never names signing, and reads against that same branch keep +succeeding right up until the write. When a write fails without a clean 409 or 404 explanation, +check the branch's protection rule before assuming the SHA is wrong and retrying. + +**Payload size.** base64 inflates `content` roughly 33% over the raw file size, and a 413 is +usually a reverse-proxy body-size limit in front of the Gitea instance rather than a Gitea-side +rejection. No amount of retrying, or changing the SHA, path, or branch, will fix it — the proxy's +config has to be raised, which is outside this skill's control. Surface that distinction instead +of retrying the same call.