初始化專案：Go 模組骨架、CLI 進入點、README、測試

- go.mod（module gitea.alterminal.com/alterminal/teai，Go 1.26） - cmd/teai/main.go：程式進入點，結束碼交由 internal/cli.Run 處理 - internal/cli：命令列架構（引數剖析、子命令分派、version 命令） - internal/cli/cli_test.go：用法輸出、version、未知命令等基本測試 - README.md：專案說明、建置與開發慣例（繁體中文） - .gitignore：建置產物、測試輸出、環境檔 - 僅使用標準庫，可離線建置；授權待維護者選定 Refs #1
2026-09-09 22:46:26 +08:00
13 changed files with 25 additions and 3001 deletions
@@ -1,13 +1,12 @@
 # teai
-teai 是 Gitea 的命令列（CLI）工具，以更完整、更可靠的方式操作 Gitea。
+teai 是 Gitea 的命令列（CLI）輔助工具，補足官方 `tea` CLI 缺少的功能。
 名稱取「**te**a + **AI**」：這套工具主要為了讓 AI agent 能以更完整、更可靠的
 方式操作 Gitea（查詢、回覆、審核、自動化……）。
- **語言：** Go（與 Gitea 本體一致），僅用標準庫，離線可建置
+- **語言：** Go（與 Gitea 本體一致）
 - **目標站點：** `https://gitea.alterminal.com`
- **狀態：** 專案初始化中，功能尚未開始開發；本文的指令集為設計藍圖
+- **狀態：** 專案初始化中，功能尚未開始開發
 - **範圍（#3）：** 不避開 tea 已有的功能；單一工具涵蓋完整操作
 ## 安裝與建置
@@ -17,222 +16,15 @@ teai 是 Gitea 的命令列（CLI）工具，以更完整、更可靠的方式
 go build -o teai ./cmd/teai
 ```
-## 指令設計
+## 使用方式
 > 工作流規則的唯一來源是 [`alterminal/agents`](https://gitea.alterminal.com/alterminal/agents) 的 `AGENTS.md`；
 > 現行原型為 `agents/scripts/lib/gitea.py`（Python）。teai 的指令集以它為行為基準，用 Go 重寫並納入本 CLI。
 ### 設計原則
 1. **功能自主完整（#3）**：teai 自行實作完整的功能集，**不**以「tea 已有」為由略過（tea 本身存在諸多問題，見 #3）。除了 gitea.py 工作流（跨倉庫／跨組織聚合、工作流判定、機器可讀輸出），也涵蓋日常操作（issues／pulls／labels／milestones／release……），tea 只是相容參考與對照組。由單一二進位檔提供一致介面，避免多工具拼接。
 2. **規則單一來源**：「最後一則留言不是自己」等工作流判定規則以 `AGENTS.md` 為準，teai 只實作、不改義。規則要變更，先改 AGENTS.md，teai 跟著改。
 3. **機器可讀優先**：預設輸出 JSON；`--output table` 僅供人工抽查。
 4. **可直接替換原型**：`gitea.py` 的每個子命令在 teai 都有語義相同的對應命令，可交叉驗證、平滑遷移。
 5. **認證沿用 tea**：讀 `tea` 的登入組態（`TEA_CONFIG` 或 `~/.config/tea/config.yml`），不另建認證體系。
 6. **安全預設**：本期全部是查詢類（唯讀）；寫入類（留言、指派、審核者）不在本期範圍，未來加入時須明確 `--yes`。
 ### 全域介面
 ```sh
-teai [全域選項] <命令> [參數]
+# 目前僅提供骨架
 ./teai            # 顯示說明
 ./teai version    # 顯示版本資訊
 ```
-| 選項 | 說明 |
+離線環境可直接建置：本專案目前僅使用 Go 標準庫，沒有外部相依。
 | --- | --- |
 | `--url <URL>` | Gitea 站點，預設 `https://gitea.alterminal.com` |
 | `--token <TOKEN>` | API token；未給則依序嘗試 `TEAI_TOKEN` 環境變數、tea 登入組態 |
 | `--config <path>` | tea 組態檔路徑，等同 `TEA_CONFIG` |
 | `--output json\|table` | 輸出格式，預設 `json` |
 | `--timeout <dur>` | HTTP 請求逾時，預設 `30s` |
 ### 指令總覽
 | 命令 | 對應 gitea.py | 說明 |
 | --- | --- | --- |
 | `teai login list\|add\|default\|remove` | — | 管理 tea 相容登入組態（見下） |
 | `teai whoami` | `get_current_username` | 目前帳號 |
 | `teai orgs` | `for_all_organizations` | 我所屬的組織 |
 | `teai members [--has-work]` | `members [--has-work]` | Agents 團隊成員；`--has-work` 只列有未完成工作者 |
 | `teai mine` | `mine` | 分派給我、待跟進的 issues |
 | `teai pulls [--mine\|--reviewer] [--repo <owner>/<repo>]` | `pulls` 系列 | 跨倉庫 PR 跟進清單 |
 | `teai next` | `next` | 下一件該做的事 |
 | `teai stalled [--hours N]` | `stalled` | 全組織停滯項目掃描（管理者巡邏） |
 | `teai xrefs <owner>/<repo> <number>` | （內部函式公開化） | 解析內文／留言中的 issue／PR 引用 |
 | `teai version` | — | 版本資訊（骨架已實作） |
 ### 日常操作（tea 對等指令；#3 不避開 tea 已有功能）
 tea 已有的日常操作 teai 也會自行實作（一致的 JSON 輸出、同一套認證與全域選項），
 不要求使用者回頭併用 `tea`。介面語義以 `tea`／Gitea API 為相容參考，僅列出主要子命令，
 細節（旗標、欄位）在個別實作 issue 中定義：
 | 命令 | 對應 tea | 說明 |
 | --- | --- | --- |
 | `teai issues [list\|create\|view\|close\|comment…]` | `tea issues` | issues 管理（含 `--comments`、`--assignees`） |
 | `teai pulls [list\|create\|view\|merge\|comment…]` | `tea pulls` | PR 管理（含審核者、合併） |
 | `teai labels` / `teai milestones` / `teai releases` | 同名 tea 指令 | 標籤、里程碑、發佈管理 |
 | `teai repos` / `teai orgs` | `tea repos`／`tea orgs` | 倉庫與組織查詢 |
 | `teai api <path>` | `tea api` | 任意 API 呼叫（逃生口，`--method`、`--data`） |
 > 實作順序不變：先完成 gitea.py 工作流命令的 Go 化，再依 issue 逐項補齊日常操作。
 > `gitea.py` 的底線函式（`_pr_needs_author_followup`、`_resolve_xref_targets` 等）是內部實作，teai 將其放在 `internal/` 套件，不另設 CLI 命令。
 ### `teai next` — 下一件該做的事
 ```sh
 teai next                 # JSON；沒有工作 → 輸出 null，exit 0
 teai next --output table  # 人類可讀
 ```
 拾取規則（與 AGENTS.md／gitea.py 完全一致，最久未更新者優先）：
 1. 自己發起、最後一則留言不是自己的 open PR（role=author）
 2. 自己被指定為審核者、最後一則留言不是自己的 open PR（role=reviewer，含尚無留言）
 3. 分派給自己、最後一則留言不是自己的 open issue
 輸出（與 `find_next_work()` 同欄位）：
 ```json
 {
  "type": "pull",
  "role": "author",
  "repo": "alterminal/teai",
  "number": 2,
  "title": "初始化專案：Go 骨架與 CLI 進入點",
  "url": "https://gitea.alterminal.com/alterminal/teai/pulls/2"
 }
 ```
 ### `teai login` — 管理登入
 teai 與 tea 共用同一份組態檔（`--config`／`TEA_CONFIG`，預設 `~/.config/tea/config.yml`）。
 寫入採行級編輯：只動目標項目的行，未知欄位（`ssh_*` 等）與 `preferences` 區段逐字保留，
 不改壞 tea 也在使用的檔案；檔案權限 `0600`、暫存檔原子替換。
 ```sh
 teai login list                      # 列出登入（一律不含 token）
 teai login add [--url <URL>] [--name <名稱>] [--default=false] [--token <TOKEN>]
                                     # 先以 token 呼叫 GET /user 驗證，成功才寫入（並記下帳號）
 teai login default <名稱>            # 設定預設登入
 teai login remove <名稱> [--yes]     # 移除登入；移除預設者時其餘第一筆自動遞補
 ```
 - `login add` 未給 `--token` 時自 stdin 讀一行，避免 token 進 shell 歷史；token 驗證失敗（401）
  不寫入，結束碼 3。
 - 未給 `--name` 時：同站（URL 主機相同）已有登入 → 就地更新該項目；否則以 URL 主機為名稱。
 - 輸出 JSON（`--output table` 供人工查看），欄位 `name`／`url`／`user`／`default`，**永不輸出 token**。
 ### `teai stalled [--hours N]` — 管理者巡邏
 ```sh
 teai stalled              # 預設 4 小時門檻
 teai stalled --hours 6
 teai stalled --hours 48 --output table
 ```
 - **判定**：open issue／PR 的最後活動距今超過 N 小時（預設 4）。
 - **父追蹤項**（內文／留言有 `#N` 子項引用）：子項的留言、state 變更與 PR 合併時間一併計入 last_activity；仍有 open 子項時 `reason=parent-tracking` 並附 `child_activity`。
 - **冷卻**：最後留言出自 `ceo` 的項目 24 小時內不再列入（已催促過），冷卻後仍停滯會再出現。
 - **輸出**：JSON 陣列，停滯由長到短；無停滯項目 → 空陣列 `[]`。
 每筆欄位：
 ```json
 {
  "type": "issue",
  "repo": "alterminal/agents",
  "number": 30,
  "title": "…",
  "assignees": ["alex"],
  "last_comment_by": "alex",
  "last_activity_at": "2026-09-09T22:00:00+08:00",
  "stalled_hours": 10.5,
  "reason": "assignee-idle"
 }
 ```
 PR 改帶 `author` 與 `reviewers` 欄位。`reason` 取值：
 - issue：`no-assignee`、`assignee-idle`、`no-commenter`、`waiting-outside`、`parent-tracking`
 - PR：`no-reviewer`、`author-idle`、`reviewer-idle`、`no-commenter`
 ### `teai members [--has-work]`
 ```sh
 teai members              # Agents 團隊全體成員（去重、排序）
 teai members --has-work   # 只列有未完成工作的成員（判定同 next）
 ```
 ### `teai pulls [filters]`
 ```sh
 teai pulls                        # 有留言且最後一則不是作者的 open PR（跨倉庫）
 teai pulls --mine                 # 再限定：作者是我（我該跟進的 PR）
 teai pulls --reviewer             # 我是 requested reviewer、最後留言不是自己（含尚無留言）
 teai pulls --repo alterminal/teai # 限定單一倉庫
 ```
 `--mine` 與 `--reviewer` 不可併用。
 ### `teai mine`
 ```sh
 teai mine                 # 分派給我、最後一則留言不是自己的 open issues（跨所屬組織）
 ```
 ### `teai orgs` / `teai whoami`
 ```sh
 teai orgs                 # 我所屬的組織
 teai whoami               # 目前帳號（讀 tea 組態）
 ```
 ### `teai xrefs <owner>/<repo> <number>` — 引用解析
 解析該 issue／PR 內文與全部留言中的 `#N`、`repo#N`、`owner/repo#N` 引用，輸出解析後的目標清單（去重）：
 ```json
 [
  { "owner": "alterminal", "repo": "agents", "number": 32, "source": "body" }
 ]
 ```
 `stalled` 的父追蹤項判定內部呼叫同一套邏輯，不重複實作。
 ### 輸出與結束碼
 所有命令支援 `--output json|table`，預設 JSON。結束碼：
 | 碼 | 意義 |
 | --- | --- |
 | 0 | 成功（含「沒有工作」→ 輸出 `null`／`[]`） |
 | 2 | 用法錯誤（未知命令／參數） |
 | 3 | API 錯誤（連線失敗、401、403、5xx） |
 ### 與 gitea.py 的對應與遷移
 | gitea.py 子命令 | teai 對應 | 語義 |
 | --- | --- | --- |
 | `next` | `teai next` | 相同：author-PR → reviewer-PR → issue，最久未更新優先 |
 | `stalled [--hours N]` | `teai stalled [--hours N]` | 相同，含 xref 父子追蹤與冷卻 |
 | `members [--has-work]` | `teai members [--has-work]` | 相同 |
 | `pulls`／`pulls --mine`／`pulls --reviewer` | `teai pulls [--mine\|--reviewer]` | 相同 |
 | `mine` | `teai mine` | 相同 |
 | （底線函式） | `internal/` 套件 | 不設 CLI 命令；`xrefs` 為其邏輯的公開化 |
 遷移策略：
 1. 以 gitea.py 為行為基準：同帳號同時跑兩者，輸出應一致（交叉驗證）。
 2. gitea.py 保留不刪；待 AGENTS.md 改引用 teai 時才停用對應腳本。
 3. 實作順序：`whoami`／`orgs`／`members`（讀取類）→ `pulls`／`mine`／`next`（判定類）→ `stalled`（最複雜，含 xref）。
 ### 安全設計
 - 本期命令全部唯讀；寫入類命令未來加入時須 `--yes` 明確確認。
 - token 不入輸出、不入日誌；建議用 `TEAI_TOKEN` 或 tea 組態，避免出現在命令列。
 - 清單類 API 一律帶 `limit`（Gitea 預設上限 50），避免漏抓。
 - 「有無實際產出」的判斷一律對照遠端實況（API 回傳），不信任回報文字。
 ## 開發
@@ -248,7 +40,7 @@ go vet ./...      # 靜態檢查
 | --- | --- |
 | `cmd/teai/` | 程式進入點（`main`） |
 | `internal/cli/` | 命令列架構（flag 剖析、子命令分派、輸出） |
-| `internal/` 其他子套件 | 依功能新增（如 `internal/gitea`、`internal/workflow`） |
+| `internal/` 其他子套件 | 之後依功能新增（如 `internal/gitea`、`internal/cmds/`） |
 ### 慣例
@@ -1,25 +1,14 @@
-// 套件 cli 提供 teai 的命令列架構：全域選項剖析、子命令分派與輸出。
+// 套件 cli 提供 teai 的命令列架構：引數剖析、子命令分派與輸出。
 //
 // 設計目標是讓之後新增子命令時只需註冊一個 command 結構，
 // 不需要改動分派邏輯；也讓核心功能可以被測試（Run 接受 io.Writer）。
 //
 // 結束碼（見 README「輸出與結束碼」）：
 //
 //	0 成功（含「沒有工作」→ null／[]）
 //	2 用法錯誤（未知命令／參數）
 //	3 API 錯誤（連線失敗、401、403、5xx）
 package cli
 import (
 	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"sort"
 	"strings"
 	"time"
 	"gitea.alterminal.com/alterminal/teai/internal/gitea"
 )
 // Version 是目前開發中的版本號。採用語意化版本；正式發佈前以 0 開頭。
@@ -28,25 +17,13 @@ var Version = "0.1.0-dev"
 // ExitCode 是 Run 回傳的行程結束碼。
 type ExitCode int
-// 結束碼定義，對應 README「輸出與結束碼」表格。
+// 常見的結束碼定義。0 表示成功，其餘對應常見的命令列錯誤情境。
 const (
-	ExitOK    ExitCode = 0 // 成功
+	ExitOK       ExitCode = iota // 成功
-	ExitUsage ExitCode = 2 // 用法錯誤（未知命令／參數）
+	ExitUsage                    // 引數或子命令錯誤
-	ExitAPI   ExitCode = 3 // API 錯誤（連線失敗、401、403、5xx）
+	ExitInternal                 // 內部錯誤（不該發生）
 	// ExitInternal 僅供「不該發生」的內部錯誤；不在 README 保證範圍。
 	ExitInternal ExitCode = 1
 )
 // ErrUsage 表示命令用法錯誤（缺參數、參數格式不對），對應 ExitUsage。
 type ErrUsage struct {
 	// Msg 是給使用者看的說明。
 	Msg string
 }
 // Error 實作 error 介面。
 func (e *ErrUsage) Error() string { return e.Msg }
 // command 定義一個子命令：名稱、一行說明與實作。
 type command struct {
 	name  string
@@ -54,46 +31,16 @@ type command struct {
 	run   func(env *Env, args []string) error
 }
-// Globals 是一次執行的全域選項（README「全域介面」）。
+// Env 聚集一次執行所需的輸出目標，便於測試時替換。
 type Globals struct {
 	// URL 是 Gitea 站點網址。
 	URL string
 	// Token 來自 --token 旗標；空字串表示未提供（依序退回環境變數與 tea 組態）。
 	Token string
 	// ConfigPath 是 tea 組態路徑（--config，等同 TEA_CONFIG）。
 	ConfigPath string
 	// Output 是輸出格式。
 	Output gitea.Format
 	// Timeout 是 HTTP 逾時。
 	Timeout time.Duration
 }
 // defaultGlobals 回傳預設全域選項。
 func defaultGlobals() Globals {
 	return Globals{
 		URL:     "https://gitea.alterminal.com",
 		Output:  gitea.FormatJSON,
 		Timeout: gitea.DefaultTimeout,
 	}
 }
 // Env 聚集一次執行所需的輸出目標與全域選項，便於測試時替換。
 type Env struct {
 	// Out 是一般輸出（命令結果）。
 	Out io.Writer
 	// Err 是診斷輸出（錯誤、警告）。
 	Err io.Writer
 	// Globals 是剖析後的全域選項。
 	Globals Globals
 }
 // commands 是已註冊的子命令表。新增功能時在這裡註冊即可。
 var commands = map[string]*command{
 	"login": {
 		name:  "login",
 		usage: "管理登入（list/add/default/remove）",
 		run:   runLogin,
 	},
 	"version": {
 		name:  "version",
 		usage: "顯示版本資訊",
@@ -103,120 +50,32 @@ var commands = map[string]*command{
 // Run 剖析引數並分派到對應子命令，回傳行程結束碼。
 //
-// 引數結構：teai [全域選項] <命令> [命令參數]。全域選項須在命令之前；
+// 無引數或要求說明（-h/--help）時印出用法；未知子命令回 ExitUsage。
 // 無引數或要求說明（-h/--help）時印出用法；未知命令或無效選項回 ExitUsage。
 func Run(stdout, stderr io.Writer, args []string) int {
-	env := &Env{Out: stdout, Err: stderr, Globals: defaultGlobals()}
+	env := &Env{Out: stdout, Err: stderr}
 	if len(args) == 0 {
 		printUsage(env.Out)
 		return int(ExitOK)
 	}
-	rest, err := parseGlobals(&env.Globals, args)
+	switch args[0] {
 	if err != nil {
 		fmt.Fprintf(stderr, "teai: %v\n\n", err)
 		printUsage(stderr)
 		return int(ExitUsage)
 	}
 	if len(rest) == 0 {
 		printUsage(env.Out)
 		return int(ExitOK)
 	}
 	switch rest[0] {
 	case "-h", "--help", "help":
 		printUsage(env.Out)
 		return int(ExitOK)
 	case "-v", "--version", "version":
-		return dispatch(env, "version", rest[1:])
+		return dispatch(env, "version", args[1:])
 	default:
-		name := rest[0]
+		name := args[0]
 		if _, ok := commands[name]; !ok {
 			fmt.Fprintf(stderr, "teai: unknown command %q\n\n", name)
 			printUsage(stderr)
 			return int(ExitUsage)
 		}
-		return dispatch(env, name, rest[1:])
+		return dispatch(env, name, args[1:])
 	}
 }
 // globalFlags 列出全域選項的長名稱與是否需要值。
 var globalFlags = map[string]bool{
 	"--url":     true,
 	"--token":   true,
 	"--config":  true,
 	"--output":  true,
 	"--timeout": true,
 }
 // parseGlobals 從 args 前端取走全域選項，回傳剩餘引數（命令與其參數）。
 // 遇到第一個非選項引數即停；不認得的選項或缺少值都回 ErrUsage。
 func parseGlobals(g *Globals, args []string) ([]string, error) {
 	i := 0
 	for i < len(args) {
 		arg := args[i]
 		if arg == "--" {
 			return args[i+1:], nil
 		}
 		if !strings.HasPrefix(arg, "-") || arg == "-" {
 			return args[i:], nil
 		}
 		name, inline, hasInline := strings.Cut(arg, "=")
 		// -h/--help/-v/--version 不是全域選項；交回 Run 的分派處理。
 		switch name {
 		case "-h", "--help", "-v", "--version":
 			return args[i:], nil
 		}
 		need, ok := globalFlags[name]
 		if !ok {
 			return nil, &ErrUsage{Msg: fmt.Sprintf("unknown global option %q", name)}
 		}
 		var value string
 		if hasInline {
 			value = inline
 		} else {
 			if !need {
 				// 目前所有全域選項都需要值；保留機制給未來的布林選項。
 				value = ""
 			}
 			if i+1 >= len(args) {
 				return nil, &ErrUsage{Msg: fmt.Sprintf("global option %q requires a value", name)}
 			}
 			i++
 			value = args[i]
 		}
 		switch name {
 		case "--url":
 			if strings.TrimSpace(value) == "" {
 				return nil, &ErrUsage{Msg: "--url must not be empty"}
 			}
 			g.URL = value
 		case "--token":
 			g.Token = value
 		case "--config":
 			if strings.TrimSpace(value) == "" {
 				return nil, &ErrUsage{Msg: "--config must not be empty"}
 			}
 			g.ConfigPath = value
 		case "--output":
 			f, err := gitea.ParseFormat(value)
 			if err != nil {
 				return nil, &ErrUsage{Msg: err.Error()}
 			}
 			g.Output = f
 		case "--timeout":
 			d, err := time.ParseDuration(value)
 			if err != nil || d <= 0 {
 				return nil, &ErrUsage{Msg: fmt.Sprintf("invalid --timeout %q (want e.g. 30s)", value)}
 			}
 			g.Timeout = d
 		}
 		i++
 	}
 	return nil, nil
 }
 // dispatch 執行已註冊的子命令，把錯誤轉成結束碼並輸出。
 func dispatch(env *Env, name string, args []string) int {
 	cmd := commands[name]
@@ -227,45 +86,21 @@ func dispatch(env *Env, name string, args []string) int {
 	}
 	if err := cmd.run(env, fs.Args()); err != nil {
 		fmt.Fprintf(env.Err, "teai %s: %v\n", name, err)
-		return int(exitCodeFor(err))
+		return int(ExitInternal)
 	}
 	return int(ExitOK)
 }
 // exitCodeFor 把命令錯誤映射到結束碼：用法錯誤 → 2，API 錯誤 → 3，
 // 其他（內部）→ 1。
 func exitCodeFor(err error) ExitCode {
 	if err == nil {
 		return ExitOK
 	}
 	var usage *ErrUsage
 	if errors.As(err, &usage) {
 		return ExitUsage
 	}
 	var api *gitea.ErrAPI
 	if errors.As(err, &api) {
 		return ExitAPI
 	}
 	return ExitInternal
 }
 // runVersion 輸出版本資訊。
 func runVersion(env *Env, args []string) error {
 	fmt.Fprintf(env.Out, "teai version %s\n", Version)
 	return nil
 }
-// printUsage 印出用法、全域選項與已註冊的子命令清單（依名稱排序）。
+// printUsage 印出用法與已註冊的子命令清單（依名稱排序）。
 func printUsage(w io.Writer) {
 	fmt.Fprintf(w, "teai — Gitea CLI 輔助工具（tea + AI）\n\n")
-	fmt.Fprintf(w, "用法：\n  teai [全域選項] <命令> [參數]\n\n")
+	fmt.Fprintf(w, "用法：\n  teai [命令] [參數]\n\n命令：\n")
 	fmt.Fprintf(w, "全域選項：\n")
 	fmt.Fprintf(w, "  --url <URL>        Gitea 站點（預設 https://gitea.alterminal.com）\n")
 	fmt.Fprintf(w, "  --token <TOKEN>    API token；未給則依序嘗試 TEAI_TOKEN、tea 登入組態\n")
 	fmt.Fprintf(w, "  --config <path>    tea 組態檔路徑，等同 TEA_CONFIG\n")
 	fmt.Fprintf(w, "  --output <format>  輸出格式 json|table（預設 json）\n")
 	fmt.Fprintf(w, "  --timeout <dur>    HTTP 逾時（預設 30s）\n\n")
 	fmt.Fprintf(w, "命令：\n")
 	names := make([]string, 0, len(commands))
 	for name := range commands {
 		names = append(names, name)
@@ -1,123 +0,0 @@
 // exitcode_test.go 驗證結束碼映射：用法錯誤 → 2、API 錯誤 → 3、其他 → 1，
 // 以及全域選項剖析（README「輸出與結束碼」「全域介面」）。
 package cli
 import (
 	"strings"
 	"testing"
 	"gitea.alterminal.com/alterminal/teai/internal/gitea"
 )
 func TestExitCodeMapping(t *testing.T) {
 	cases := []struct {
 		name string
 		err  error
 		want ExitCode
 	}{
 		{"usage error", &ErrUsage{Msg: "bad flag"}, ExitUsage},
 		{"api error 401", &gitea.ErrAPI{StatusCode: 401, Op: "GET /api/v1/user"}, ExitAPI},
 		{"api error transport", &gitea.ErrAPI{Op: "GET /api/v1/user", Err: errString("dial tcp")}, ExitAPI},
 		{"wrapped api error", wrapped(&gitea.ErrAPI{StatusCode: 500}), ExitAPI},
 		{"other error", errString("boom"), ExitInternal},
 		{"nil maps to OK", nil, ExitOK},
 	}
 	for _, tc := range cases {
 		if got := exitCodeFor(tc.err); got != tc.want {
 			t.Errorf("%s: exitCodeFor = %d, want %d", tc.name, got, tc.want)
 		}
 	}
 }
 func TestRunExitCodes(t *testing.T) {
 	t.Run("unknown command exits 2", func(t *testing.T) {
 		_, _, code := run("no-such")
 		if code != 2 {
 			t.Fatalf("code = %d, want 2", code)
 		}
 	})
 	t.Run("unknown global option exits 2", func(t *testing.T) {
 		_, _, code := run("--wat", "version")
 		if code != 2 {
 			t.Fatalf("code = %d, want 2", code)
 		}
 	})
 	t.Run("missing option value exits 2", func(t *testing.T) {
 		_, _, code := run("--output")
 		if code != 2 {
 			t.Fatalf("code = %d, want 2", code)
 		}
 	})
 	t.Run("invalid output value exits 2", func(t *testing.T) {
 		_, _, code := run("--output=yaml", "version")
 		if code != 2 {
 			t.Fatalf("code = %d, want 2", code)
 		}
 	})
 	t.Run("invalid timeout exits 2", func(t *testing.T) {
 		_, _, code := run("--timeout=soon", "version")
 		if code != 2 {
 			t.Fatalf("code = %d, want 2", code)
 		}
 	})
 	t.Run("version still works with globals", func(t *testing.T) {
 		stdout, _, code := run("--output=table", "--timeout=10s", "version")
 		if code != 0 || !strings.Contains(stdout, "teai version ") {
 			t.Fatalf("code = %d stdout = %q", code, stdout)
 		}
 	})
 }
 func TestParseGlobals(t *testing.T) {
 	g := defaultGlobals()
 	rest, err := parseGlobals(&g, []string{
 		"--url", "https://example.com",
 		"--token=tok",
 		"--config", "/tmp/c.yml",
 		"--output", "table",
 		"--timeout", "45s",
 		"next",
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
 	if len(rest) != 1 || rest[0] != "next" {
 		t.Fatalf("rest = %v, want [next]", rest)
 	}
 	if g.URL != "https://example.com" || g.Token != "tok" || g.ConfigPath != "/tmp/c.yml" {
 		t.Fatalf("globals = %+v", g)
 	}
 	if g.Output != gitea.FormatTable {
 		t.Fatalf("output = %v, want table", g.Output)
 	}
 	if g.Timeout.String() != "45s" {
 		t.Fatalf("timeout = %s", g.Timeout)
 	}
 }
 func TestParseGlobalsStopsAtCommand(t *testing.T) {
 	g := defaultGlobals()
 	rest, err := parseGlobals(&g, []string{"version", "--output", "table"})
 	if err != nil {
 		t.Fatal(err)
 	}
 	// 命令之後的選項屬於命令，不屬於全域。
 	if len(rest) != 3 || rest[0] != "version" {
 		t.Fatalf("rest = %v", rest)
 	}
 }
 // errString 把字串轉成 error（測試輔助）。
 type errStr string
 func (e errStr) Error() string { return string(e) }
 func errString(s string) error { return errStr(s) }
 // wrapped 包一層 error（測試 errors.As 穿透）。
 type wrappedErr struct{ inner error }
 func (w wrappedErr) Error() string { return "wrapped: " + w.inner.Error() }
 func (w wrappedErr) Unwrap() error { return w.inner }
 func wrapped(inner error) error { return wrappedErr{inner} }
@@ -1,365 +0,0 @@
 // login.go — teai login 指令：管理 tea 相容的登入組態。
 //
 // teai 與 tea 共用同一份組態檔（README 設計原則 5），login 的職責是：
 // 以 token 向站點驗證（GET /user），成功後才寫入組態並記下帳號。
 // token 只走記憶體與組態檔，不進輸出、日誌或錯誤訊息。
 //
 // 子命令：list／add／default／remove。
 package cli
 import (
 	"bufio"
 	"context"
 	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
 	"gitea.alterminal.com/alterminal/teai/internal/gitea"
 )
 // loginStdin 是讀 token 與確認的輸入（測試可替換）。
 var loginStdin io.Reader = os.Stdin
 // loginConfigPath 回傳組態檔路徑：--config／TEA_CONFIG 優先，其次
 // ~/.config/tea/config.yml。找不到可用路徑回空字串。
 func loginConfigPath(g Globals) string {
 	if p := strings.TrimSpace(g.ConfigPath); p != "" {
 		return expandHome(p)
 	}
 	if p := os.Getenv("TEA_CONFIG"); strings.TrimSpace(p) != "" {
 		return expandHome(strings.TrimSpace(p))
 	}
 	home, err := os.UserHomeDir()
 	if err != nil || home == "" {
 		return ""
 	}
 	return filepath.Join(home, ".config", "tea", "config.yml")
 }
 // expandHome 展開路徑開頭的 ~。
 func expandHome(p string) string {
 	if p == "~" || strings.HasPrefix(p, "~/") {
 		if home, err := os.UserHomeDir(); err == nil {
 			return filepath.Join(home, strings.TrimPrefix(p, "~"))
 		}
 	}
 	return p
 }
 // runLogin 是 teai login 的進入點：分派子命令。
 func runLogin(env *Env, args []string) error {
 	if len(args) == 0 {
 		return &ErrUsage{Msg: "login requires a subcommand: list, add, default, remove"}
 	}
 	sub, rest := args[0], args[1:]
 	switch sub {
 	case "list":
 		return runLoginList(env, rest)
 	case "add":
 		return runLoginAdd(env, rest)
 	case "default":
 		return runLoginDefault(env, rest)
 	case "remove":
 		return runLoginRemove(env, rest)
 	default:
 		return &ErrUsage{Msg: fmt.Sprintf("unknown login subcommand %q (want list, add, default, remove)", sub)}
 	}
 }
 // loginFields 是輸出欄位（不含 token）。
 var loginFields = []gitea.Field{
 	{Name: "name"},
 	{Name: "url"},
 	{Name: "user"},
 	{Name: "default"},
 }
 // printLoginList 依格式輸出登入清單。
 func printLoginList(env *Env, logins []gitea.LoginEntry) error {
 	p := gitea.Printer{Format: env.Globals.Output, Out: env.Out}
 	rows := make([]gitea.Values, 0, len(logins))
 	for _, l := range logins {
 		rows = append(rows, gitea.Values{l.Name, l.URL, l.User, l.Default})
 	}
 	return p.PrintList(loginFields, rows)
 }
 // runLoginList 列出組態中的登入（一律不含 token）。
 func runLoginList(env *Env, args []string) error {
 	fs := flag.NewFlagSet("teai login list", flag.ContinueOnError)
 	fs.SetOutput(env.Err)
 	if err := fs.Parse(args); err != nil {
 		return &ErrUsage{Msg: err.Error()}
 	}
 	if fs.NArg() > 0 {
 		return &ErrUsage{Msg: fmt.Sprintf("unexpected argument %q", fs.Arg(0))}
 	}
 	path := loginConfigPath(env.Globals)
 	if path == "" {
 		return fmt.Errorf("cannot determine config path")
 	}
 	logins, err := gitea.ListLoginsFile(path)
 	if err != nil {
 		return fmt.Errorf("read config %s: %w", path, err)
 	}
 	return printLoginList(env, logins)
 }
 // runLoginAdd 新增或更新登入：先驗證 token（GET /user），成功才寫入。
 //
 // token 來源：--token 旗標，或 stdin（預設未給旗標時讀一行，
 // 避免 token 進 shell 歷史）。
 func runLoginAdd(env *Env, args []string) error {
 	fs := flag.NewFlagSet("teai login add", flag.ContinueOnError)
 	fs.SetOutput(env.Err)
 	urlFlag := fs.String("url", env.Globals.URL, "Gitea 站點網址")
 	nameFlag := fs.String("name", "", "登入名稱（省略時取 URL 主機）")
 	tokenFlag := fs.String("token", "", "API token（省略時自 stdin 讀一行）")
 	defaultFlag := fs.Bool("default", true, "設為預設登入")
 	if err := fs.Parse(args); err != nil {
 		return &ErrUsage{Msg: err.Error()}
 	}
 	if fs.NArg() > 0 {
 		return &ErrUsage{Msg: fmt.Sprintf("unexpected argument %q", fs.Arg(0))}
 	}
 	siteURL := strings.TrimSuffix(strings.TrimSpace(*urlFlag), "/")
 	if siteURL == "" {
 		return &ErrUsage{Msg: "--url must not be empty"}
 	}
 	token := strings.TrimSpace(*tokenFlag)
 	if token == "" {
 		t, err := readLineFrom(loginStdin)
 		if err != nil {
 			return fmt.Errorf("read token from stdin: %w", err)
 		}
 		token = t
 	}
 	if token == "" {
 		return &ErrUsage{Msg: "token must not be empty"}
 	}
 	path := loginConfigPath(env.Globals)
 	if path == "" {
 		return fmt.Errorf("cannot determine config path")
 	}
 	data, err := os.ReadFile(path)
 	if err != nil && !os.IsNotExist(err) {
 		return fmt.Errorf("read config %s: %w", path, err)
 	}
 	name := strings.TrimSpace(*nameFlag)
 	if name == "" {
 		// 未指定名稱：同站（主機相同）已有登入就就地更新，避免重複項目。
 		if existing, ok := findLoginByHost(data, siteURL); ok {
 			name = existing.Name
 		} else {
 			name = defaultLoginName(siteURL)
 		}
 	}
 	// 先驗證再寫入：token 無效時不動組態檔。
 	user, err := verifyToken(env, siteURL, token)
 	if err != nil {
 		return err
 	}
 	out, final, err := gitea.UpsertLogin(data, gitea.LoginEntry{
 		Name:    name,
 		URL:     siteURL,
 		Token:   token,
 		Default: *defaultFlag,
 		User:    user,
 	}, *defaultFlag)
 	if err != nil {
 		return err
 	}
 	if err := gitea.SaveTeaConfigFile(path, out); err != nil {
 		return err
 	}
 	p := gitea.Printer{Format: env.Globals.Output, Out: env.Out}
 	return p.PrintOne(loginFields, gitea.Values{final.Name, final.URL, final.User, final.Default})
 }
 // readLineFrom 讀一行並去除頭尾空白；EOF 且無內容回空字串。
 func readLineFrom(r io.Reader) (string, error) {
 	line, err := bufio.NewReader(r).ReadString('\n')
 	if err != nil && err != io.EOF {
 		return "", err
 	}
 	return strings.TrimSpace(line), nil
 }
 // verifyToken 以 token 呼叫 GET /user，回傳帳號名稱。
 // 401 特別標明是 token 遭拒，其餘依 *gitea.ErrAPI 對應結束碼 3。
 func verifyToken(env *Env, siteURL, token string) (string, error) {
 	c, err := gitea.New(siteURL, token, env.Globals.Timeout)
 	if err != nil {
 		return "", &ErrUsage{Msg: err.Error()}
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), env.Globals.Timeout)
 	defer cancel()
 	var out struct {
 		Login string `json:"login"`
 	}
 	if err := c.GetJSON(ctx, "/user", &out); err != nil {
 		var api *gitea.ErrAPI
 		if errors.As(err, &api) && api.StatusCode == 401 {
 			// 包 %w 保留 *ErrAPI：結束碼對應 3（API 錯誤）。
 			return "", fmt.Errorf("token rejected by %s: %w", siteURL, api)
 		}
 		return "", err
 	}
 	if out.Login == "" {
 		return "", fmt.Errorf("empty account name returned by %s", siteURL)
 	}
 	return out.Login, nil
 }
 // runLoginDefault 設定預設登入。
 func runLoginDefault(env *Env, args []string) error {
 	fs := flag.NewFlagSet("teai login default", flag.ContinueOnError)
 	fs.SetOutput(env.Err)
 	if err := fs.Parse(args); err != nil {
 		return &ErrUsage{Msg: err.Error()}
 	}
 	if fs.NArg() != 1 {
 		return &ErrUsage{Msg: "login default requires exactly one login name"}
 	}
 	name := fs.Arg(0)
 	data, err := readLoginConfig(env, "login default")
 	if err != nil {
 		return err
 	}
 	entry, found := findLogin(data, name)
 	if !found {
 		return fmt.Errorf("gitea: login %q not found", name)
 	}
 	out, err := gitea.SetDefaultLogin(data, name)
 	if err != nil {
 		return err
 	}
 	if err := saveLoginConfig(env, out); err != nil {
 		return err
 	}
 	p := gitea.Printer{Format: env.Globals.Output, Out: env.Out}
 	return p.PrintOne(loginFields, gitea.Values{entry.Name, entry.URL, entry.User, true})
 }
 // runLoginRemove 移除登入；未加 --yes 時先確認。
 func runLoginRemove(env *Env, args []string) error {
 	fs := flag.NewFlagSet("teai login remove", flag.ContinueOnError)
 	fs.SetOutput(env.Err)
 	yesFlag := fs.Bool("yes", false, "跳過確認")
 	if err := fs.Parse(args); err != nil {
 		return &ErrUsage{Msg: err.Error()}
 	}
 	if fs.NArg() != 1 {
 		return &ErrUsage{Msg: "login remove requires exactly one login name"}
 	}
 	name := fs.Arg(0)
 	data, err := readLoginConfig(env, "login remove")
 	if err != nil {
 		return err
 	}
 	entry, found := findLogin(data, name)
 	if !found {
 		return fmt.Errorf("gitea: login %q not found", name)
 	}
 	if !*yesFlag {
 		confirmed, err := confirmRemove(env, entry)
 		if err != nil {
 			return err
 		}
 		if !confirmed {
 			fmt.Fprintln(env.Out, "cancelled")
 			return nil
 		}
 	}
 	out, promoted, err := gitea.RemoveLogin(data, name)
 	if err != nil {
 		return err
 	}
 	if err := saveLoginConfig(env, out); err != nil {
 		return err
 	}
 	if promoted != "" {
 		fmt.Fprintf(env.Err, "default login is now %q\n", promoted)
 	}
 	p := gitea.Printer{Format: env.Globals.Output, Out: env.Out}
 	return p.PrintOne(loginFields, gitea.Values{entry.Name, entry.URL, entry.User, false})
 }
 // confirmRemove 印出待移除項目（不含 token）並讀 y/yes 確認；
 // 其他輸入（含 EOF）一律視為取消。
 func confirmRemove(env *Env, entry gitea.LoginEntry) (bool, error) {
 	fmt.Fprintf(env.Err, "remove login %q (url %s, user %s)? [y/N] ", entry.Name, entry.URL, entry.User)
 	line, err := readLineFrom(loginStdin)
 	if err != nil {
 		return false, fmt.Errorf("read confirmation: %w", err)
 	}
 	switch strings.ToLower(line) {
 	case "y", "yes":
 		return true, nil
 	default:
 		return false, nil
 	}
 }
 // readLoginConfig 讀組態檔內容；路徑無法判定或讀取失敗時回錯。
 func readLoginConfig(env *Env, op string) ([]byte, error) {
 	path := loginConfigPath(env.Globals)
 	if path == "" {
 		return nil, fmt.Errorf("cannot determine config path")
 	}
 	data, err := os.ReadFile(path)
 	if err != nil {
 		return nil, fmt.Errorf("%s: read config %s: %w", op, path, err)
 	}
 	return data, nil
 }
 // saveLoginConfig 原子寫回組態檔。
 func saveLoginConfig(env *Env, data []byte) error {
 	path := loginConfigPath(env.Globals)
 	if path == "" {
 		return fmt.Errorf("cannot determine config path")
 	}
 	return gitea.SaveTeaConfigFile(path, data)
 }
 // findLoginByHost 在組態內容中找 URL 主機與 siteURL 相同的登入。
 func findLoginByHost(data []byte, siteURL string) (gitea.LoginEntry, bool) {
 	for _, l := range gitea.ListLogins(data) {
 		if gitea.HostOf(l.URL) == gitea.HostOf(siteURL) {
 			return l, true
 		}
 	}
 	return gitea.LoginEntry{}, false
 }
 // findLogin 在組態內容中找指定名稱的登入。
 func findLogin(data []byte, name string) (gitea.LoginEntry, bool) {
 	for _, l := range gitea.ListLogins(data) {
 		if l.Name == name {
 			return l, true
 		}
 	}
 	return gitea.LoginEntry{}, false
 }
 // defaultLoginName 以 URL 主機作為登入名稱（同 tea 的習慣）。
 func defaultLoginName(rawURL string) string {
 	s := rawURL
 	if !strings.Contains(s, "://") {
 		s = "https://" + s
 	}
 	if u, err := url.Parse(s); err == nil && u.Host != "" {
 		return u.Host
 	}
 	return rawURL
 }
@@ -1,288 +0,0 @@
 // login_test.go 驗證 login 指令：list/add/default/remove 的輸出、
 // 驗證流程（先 GET /user 再寫入）、401 不寫檔、token 不外洩。
 package cli
 import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strings"
 	"sync/atomic"
 	"testing"
 	"gitea.alterminal.com/alterminal/teai/internal/gitea"
 )
 // loginTestEnv 建立測試環境：臨時組態檔路徑 + 可替換的 stdin。
 func loginTestEnv(t *testing.T, configContent string) (args []string, configPath string) {
 	t.Helper()
 	dir := t.TempDir()
 	configPath = filepath.Join(dir, "config.yml")
 	if configContent != "" {
 		if err := os.WriteFile(configPath, []byte(configContent), 0o600); err != nil {
 			t.Fatal(err)
 		}
 	}
 	t.Setenv("TEA_CONFIG", configPath)
 	return []string{"--config", configPath}, configPath
 }
 // newAPIServer 建立假的 Gitea API：/user 檢查 Authorization。
 func newAPIServer(t *testing.T, wantToken string, status int) (*httptest.Server, *atomic.Value) {
 	t.Helper()
 	var gotAuth atomic.Value
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		gotAuth.Store(r.Header.Get("Authorization"))
 		if r.URL.Path != "/api/v1/user" {
 			w.WriteHeader(http.StatusNotFound)
 			return
 		}
 		if status != 0 {
 			w.WriteHeader(status)
 			return
 		}
 		fmt.Fprint(w, `{"login":"ceo"}`)
 	}))
 	t.Cleanup(srv.Close)
 	return srv, &gotAuth
 }
 func TestLoginListJSONNoToken(t *testing.T) {
 	prefix, _ := loginTestEnv(t, `logins:
    - name: alterminal
      url: https://gitea.alterminal.com
      token: super-secret
      default: true
      user: ceo
 `)
 	stdout, _, code := run(append(prefix, "login", "list")...)
 	if code != 0 {
 		t.Fatalf("code = %d", code)
 	}
 	if !strings.Contains(stdout, `"name":"alterminal"`) || !strings.Contains(stdout, `"user":"ceo"`) {
 		t.Fatalf("unexpected output: %s", stdout)
 	}
 	if strings.Contains(stdout, "super-secret") || strings.Contains(stdout, "token") {
 		t.Fatalf("token leaked: %s", stdout)
 	}
 }
 func TestLoginListEmpty(t *testing.T) {
 	prefix, path := loginTestEnv(t, "")
 	if _, err := os.Stat(path); err == nil {
 		t.Fatal("precondition: config should not exist")
 	}
 	stdout, _, code := run(append(prefix, "login", "list")...)
 	if code != 0 {
 		t.Fatalf("code = %d", code)
 	}
 	if strings.TrimSpace(stdout) != "[]" {
 		t.Fatalf("want [], got %q", stdout)
 	}
 }
 func TestLoginAddVerifiesThenWrites(t *testing.T) {
 	srv, gotAuth := newAPIServer(t, "tok-xyz", 0)
 	prefix, configPath := loginTestEnv(t, "")
 	stdout, _, code := run(append(prefix,
 		"--url", srv.URL, "login", "add", "--name", "test-site", "--token", "tok-xyz")...)
 	if code != 0 {
 		t.Fatalf("code = %d, stdout = %s", code, stdout)
 	}
 	if got := gotAuth.Load(); got != "token tok-xyz" {
 		t.Fatalf("server saw Authorization %v", got)
 	}
 	if !strings.Contains(stdout, `"name":"test-site"`) || !strings.Contains(stdout, `"user":"ceo"`) {
 		t.Fatalf("unexpected output: %s", stdout)
 	}
 	if strings.Contains(stdout, "tok-xyz") {
 		t.Fatalf("token leaked: %s", stdout)
 	}
 	// 寫入的組態可被解析，且欄位齊全。
 	data, err := os.ReadFile(configPath)
 	if err != nil {
 		t.Fatal(err)
 	}
 	logins := gitea.ListLogins(data)
 	if len(logins) != 1 {
 		t.Fatalf("want 1 login, got %d:\n%s", len(logins), data)
 	}
 	l := logins[0]
 	if l.Name != "test-site" || l.URL != srv.URL || l.Token != "tok-xyz" || !l.Default || l.User != "ceo" {
 		t.Fatalf("entry mismatch: %+v", l)
 	}
 	info, _ := os.Stat(configPath)
 	if info.Mode().Perm() != 0o600 {
 		t.Fatalf("perm = %v", info.Mode().Perm())
 	}
 }
 func TestLoginAddTokenFromStdin(t *testing.T) {
 	srv, _ := newAPIServer(t, "stdin-tok", 0)
 	prefix, configPath := loginTestEnv(t, "")
 	old := loginStdin
 	loginStdin = strings.NewReader("stdin-tok\n")
 	defer func() { loginStdin = old }()
 	stdout, _, code := run(append(prefix, "--url", srv.URL, "login", "add")...)
 	if code != 0 {
 		t.Fatalf("code = %d, stdout = %s", code, stdout)
 	}
 	data, _ := os.ReadFile(configPath)
 	if l := gitea.ListLogins(data); len(l) != 1 || l[0].Token != "stdin-tok" {
 		t.Fatalf("stdin token not saved:\n%s", data)
 	}
 }
 func TestLoginAddRejected401NoWrite(t *testing.T) {
 	srv, _ := newAPIServer(t, "", http.StatusUnauthorized)
 	prefix, configPath := loginTestEnv(t, `logins:
    - name: keep
      url: https://keep.example.com
      token: keep-tok
      default: true
 `)
 	_, stderr, code := run(append(prefix,
 		"--url", srv.URL, "login", "add", "--token", "bad-tok")...)
 	if code != int(ExitAPI) {
 		t.Fatalf("401 should exit 3, got %d (stderr %s)", code, stderr)
 	}
 	if !strings.Contains(stderr, "401") {
 		t.Fatalf("stderr should mention 401: %s", stderr)
 	}
 	// 組態不受影響。
 	data, _ := os.ReadFile(configPath)
 	if l := gitea.ListLogins(data); len(l) != 1 || l[0].Token != "keep-tok" {
 		t.Fatalf("config must be untouched:\n%s", data)
 	}
 }
 func TestLoginAddUpdatesExistingInPlace(t *testing.T) {
 	srv, _ := newAPIServer(t, "new-tok", 0)
 	prefix, configPath := loginTestEnv(t, `logins:
    - name: alterminal
      url: `+srv.URL+`
      token: old-tok
      default: true
      user: someone-else
      ssh_key: "keep-me"
 preferences:
    editor: false
 `)
 	stdout, _, code := run(append(prefix, "--url", srv.URL, "login", "add", "--token", "new-tok")...)
 	if code != 0 {
 		t.Fatalf("code = %d, out = %s", code, stdout)
 	}
 	data, _ := os.ReadFile(configPath)
 	s := string(data)
 	// 未給 --name：同站既有項目（name: alterminal）就地更新，不新增重複項目。
 	if strings.Contains(stdout, `"name":"127.0.0.1:`) {
 		t.Fatalf("should reuse existing entry name, got %s", stdout)
 	}
 	if !strings.Contains(s, "- name: alterminal") {
 		t.Fatalf("existing entry name lost:\n%s", s)
 	}
 	if strings.Contains(s, "old-tok") || !strings.Contains(s, "token: new-tok") {
 		t.Fatalf("token not replaced:\n%s", s)
 	}
 	if !strings.Contains(s, `ssh_key: "keep-me"`) || !strings.Contains(s, "editor: false") {
 		t.Fatalf("unrelated content lost:\n%s", s)
 	}
 	if !strings.Contains(s, "user: ceo") {
 		t.Fatalf("user not refreshed:\n%s", s)
 	}
 }
 func TestLoginDefaultAndRemove(t *testing.T) {
 	cfg := `logins:
    - name: a
      url: https://a.example.com
      token: ta
      default: true
    - name: b
      url: https://b.example.com
      token: tb
      default: false
 `
 	prefix, configPath := loginTestEnv(t, cfg)
 	stdout, _, code := run(append(prefix, "login", "default", "b")...)
 	if code != 0 || !strings.Contains(stdout, `"name":"b"`) {
 		t.Fatalf("default failed: code=%d out=%s", code, stdout)
 	}
 	data, _ := os.ReadFile(configPath)
 	if l := gitea.ListLogins(data); !l[1].Default || l[0].Default {
 		t.Fatalf("default not switched:\n%s", data)
 	}
 	// remove --yes：移除預設者 b，a 遞補。
 	stdout, _, code = run(append(prefix, "login", "remove", "--yes", "b")...)
 	if code != 0 || !strings.Contains(stdout, `"name":"b"`) {
 		t.Fatalf("remove failed: code=%d out=%s", code, stdout)
 	}
 	data, _ = os.ReadFile(configPath)
 	if l := gitea.ListLogins(data); len(l) != 1 || l[0].Name != "a" || !l[0].Default {
 		t.Fatalf("promote failed:\n%s", data)
 	}
 }
 func TestLoginRemoveAsksConfirmation(t *testing.T) {
 	prefix, _ := loginTestEnv(t, `logins:
    - name: a
      url: https://a.example.com
      token: ta
      default: true
 `)
 	old := loginStdin
 	loginStdin = strings.NewReader("n\n")
 	defer func() { loginStdin = old }()
 	_, _, code := run(append(prefix, "login", "remove", "a")...)
 	if code != 0 {
 		t.Fatalf("cancel should still exit 0, got %d", code)
 	}
 	// 取消：檔案不變（token 仍在）。
 	data, _ := os.ReadFile(filepath.Dir(prefix[1]) + "/config.yml")
 	if !strings.Contains(string(data), "token: ta") {
 		t.Fatalf("cancelled remove must not write:\n%s", data)
 	}
 }
 func TestLoginUnknownSubcommandUsage(t *testing.T) {
 	prefix, _ := loginTestEnv(t, "")
 	_, stderr, code := run(append(prefix, "login", "bogus")...)
 	if code != int(ExitUsage) {
 		t.Fatalf("want exit 2, got %d", code)
 	}
 	if !strings.Contains(stderr, "unknown login subcommand") {
 		t.Fatalf("stderr: %s", stderr)
 	}
 }
 func TestLoginNoSubcommandUsage(t *testing.T) {
 	prefix, _ := loginTestEnv(t, "")
 	_, stderr, code := run(append(prefix, "login")...)
 	if code != int(ExitUsage) {
 		t.Fatalf("want exit 2, got %d", code)
 	}
 	if !strings.Contains(stderr, "subcommand") {
 		t.Fatalf("stderr: %s", stderr)
 	}
 }
 func TestLoginRemoveNotFound(t *testing.T) {
 	prefix, _ := loginTestEnv(t, "logins: []\n")
 	_, stderr, code := run(append(prefix, "login", "remove", "--yes", "ghost")...)
 	if code != int(ExitInternal) {
 		t.Fatalf("want exit 1, got %d", code)
 	}
 	if !strings.Contains(stderr, `login "ghost" not found`) {
 		t.Fatalf("stderr: %s", stderr)
 	}
 }
 func TestLoginRegisteredInUsage(t *testing.T) {
 	stdout, _, code := run()
 	if code != 0 || !strings.Contains(stdout, "login") {
 		t.Fatalf("usage should list login: %s", stdout)
 	}
 }
@@ -1,268 +0,0 @@
 // auth.go — 認證來源的解析與選序。
 //
 // 選序（README「全域介面」）：--token 旗標 → TEAI_TOKEN 環境變數 →
 // tea 登入組態（TEA_CONFIG 指定的路徑，或 ~/.config/tea/config.yml）。
 // token 一律只在記憶體傳遞，不寫入輸出、日誌或錯誤訊息。
 package gitea
 import (
 	"fmt"
 	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
 )
 // TokenSource 標記 token 的來源，供測試與診斷（不含 token 本身）。
 type TokenSource int
 const (
 	// SourceNone 表示沒有任何可用 token（匿名存取）。
 	SourceNone TokenSource = iota
 	// SourceFlag 是 --token 旗標。
 	SourceFlag
 	// SourceEnv 是 TEAI_TOKEN 環境變數。
 	SourceEnv
 	// SourceTeaConfig 是 tea 登入組態。
 	SourceTeaConfig
 )
 // String 回傳來源名稱（診斷用）。
 func (s TokenSource) String() string {
 	switch s {
 	case SourceFlag:
 		return "flag"
 	case SourceEnv:
 		return "env"
 	case SourceTeaConfig:
 		return "tea-config"
 	default:
 		return "none"
 	}
 }
 // EnvLookup 是環境變數查詢介面（測試可替換）。
 type EnvLookup func(key string) (string, bool)
 // ReadFileFunc 是檔案讀取介面（測試可替換）。
 type ReadFileFunc func(path string) ([]byte, error)
 // osEnv / osReadFile 是正式環境的預設實作。
 func osEnv(key string) (string, bool) {
 	v, ok := os.LookupEnv(key)
 	return v, ok
 }
 func osReadFile(path string) ([]byte, error) {
 	// 假設路徑已被 ExpandConfigPath 展開為絕對路徑。
 	return os.ReadFile(path)
 }
 // AuthOptions 聚合認證解析所需的輸入。
 type AuthOptions struct {
 	// FlagToken 是 --token 旗標值；空字串表示未提供。
 	FlagToken string
 	// SiteURL 是目標站點（用來比對 tea 組態中的 login url）。
 	SiteURL string
 	// Env 是環境變數查詢；nil 時用 os.LookupEnv。
 	Env EnvLookup
 	// ConfigPath 是 tea 組態的明確路徑（TEA_CONFIG 或 --config）。
 	// 空字串表示用預設 ~/.config/tea/config.yml。
 	ConfigPath string
 	// Home 是使用者家目錄（展開 ~ 用）；空字串表示不展開。
 	Home string
 	// ReadFile 是檔案讀取函式；nil 時用 os.ReadFile。
 	ReadFile ReadFileFunc
 }
 // ResolveToken 依選序解析 token：flag → env(TEAI_TOKEN) → tea 組態。
 //
 // 找不到任何 token 時回傳 ("", SourceNone, nil)——查詢公開端點不需要
 // token，是否為錯由呼叫端依情境決定。組態檔存在但解析失敗（格式錯誤）
 // 時回傳錯誤，因為這通常代表組態被改壞了，靜默降級為匿名會更難查。
 func ResolveToken(opts AuthOptions) (string, TokenSource, error) {
 	if t := strings.TrimSpace(opts.FlagToken); t != "" {
 		return t, SourceFlag, nil
 	}
 	env := opts.Env
 	if env == nil {
 		env = osEnv
 	}
 	if t, ok := env("TEAI_TOKEN"); ok && strings.TrimSpace(t) != "" {
 		return strings.TrimSpace(t), SourceEnv, nil
 	}
 	path := opts.ConfigPath
 	if path == "" {
 		// --config 未給時，先看 TEA_CONFIG 環境變數。
 		if p, ok := env("TEA_CONFIG"); ok && strings.TrimSpace(p) != "" {
 			path = strings.TrimSpace(p)
 		}
 	}
 	if path == "" {
 		home := opts.Home
 		if home == "" {
 			h, err := os.UserHomeDir()
 			if err != nil {
 				return "", SourceNone, nil
 			}
 			home = h
 		}
 		if home == "" {
 			return "", SourceNone, nil
 		}
 		path = filepath.Join(home, ".config", "tea", "config.yml")
 	}
 	if path == "" {
 		return "", SourceNone, nil
 	}
 	readFile := opts.ReadFile
 	if readFile == nil {
 		readFile = osReadFile
 	}
 	data, err := readFile(path)
 	if err != nil {
 		// 組態不存在或讀不到：視為沒有這個來源，不是錯誤。
 		return "", SourceNone, nil
 	}
 	login, err := parseTeaConfig(data, opts.SiteURL)
 	if err != nil {
 		return "", SourceNone, fmt.Errorf("gitea: parse tea config %s: %w", path, err)
 	}
 	if login.Token == "" {
 		return "", SourceNone, nil
 	}
 	return login.Token, SourceTeaConfig, nil
 }
 // teaLogin 是 tea 組態中一筆登入資料（只取 teai 需要的欄位）。
 type teaLogin struct {
 	Name    string
 	URL     string
 	Token   string
 	Default bool
 }
 // parseTeaConfig 從 tea 的 config.yml 內容挑出最匹配 siteURL 的登入：
 // url 主機相同者優先，其中 default: true 最優，否則取第一筆；
 // 都不相同時退而取 default: true，再退第一筆。
 //
 // 僅解析 tea 實際寫出的 YAML 子集：頂層 `logins:` 清單，項目為
 // `key: value` 的平面映射。不處理錨點、多文件、巢狀清單——tea 不會寫出
 // 這些，遇到也不該默默誤讀。
 func parseTeaConfig(data []byte, siteURL string) (teaLogin, error) {
 	var logins []teaLogin
 	inLogins := false
 	cur := -1 // 目前項目在 logins 的索引；-1 表示尚未開始任何項目
 	for lineNo, raw := range strings.Split(string(data), "\n") {
 		line := strings.TrimRight(raw, "\r")
 		// 忽略註解行（行的第一個非空白字元是 #）。
 		trimmed := strings.TrimSpace(line)
 		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
 			continue
 		}
 		indent := len(line) - len(strings.TrimLeft(line, " "))
 		if indent == 0 {
 			inLogins = strings.HasPrefix(trimmed, "logins:")
 			cur = -1
 			continue
 		}
 		if !inLogins {
 			continue
 		}
 		if strings.HasPrefix(trimmed, "- ") || trimmed == "-" {
 			// 新的清單項目；`- name: x` 形式同行帶鍵值。
 			logins = append(logins, teaLogin{})
 			cur = len(logins) - 1
 			rest := strings.TrimSpace(strings.TrimPrefix(trimmed, "-"))
 			if rest != "" {
 				if err := applyLoginField(&logins[cur], rest, lineNo+1); err != nil {
 					return teaLogin{}, err
 				}
 			}
 			continue
 		}
 		if cur < 0 {
 			// logins: 底下卻不是清單項目——不是預期的結構。
 			return teaLogin{}, fmt.Errorf("line %d: expected list item under logins:", lineNo+1)
 		}
 		if err := applyLoginField(&logins[cur], trimmed, lineNo+1); err != nil {
 			return teaLogin{}, err
 		}
 	}
 	if len(logins) == 0 {
 		return teaLogin{}, nil
 	}
 	wantHost := hostOf(siteURL)
 	// 第一輪：主機相符者，default 優先，否則第一筆。
 	var fallback = -1   // 主機相符的非 default
 	var anyDefault = -1 // 全域 default
 	for i, l := range logins {
 		if wantHost != "" && hostOf(l.URL) == wantHost {
 			if l.Default {
 				return l, nil
 			}
 			if fallback < 0 {
 				fallback = i
 			}
 		}
 		if l.Default && anyDefault < 0 {
 			anyDefault = i
 		}
 	}
 	if fallback >= 0 {
 		return logins[fallback], nil
 	}
 	if anyDefault >= 0 {
 		return logins[anyDefault], nil
 	}
 	return logins[0], nil
 }
 // applyLoginField 把 `key: value` 套用到 login；value 的引號會剝除。
 func applyLoginField(l *teaLogin, kv string, lineNo int) error {
 	key, value, ok := strings.Cut(kv, ":")
 	if !ok {
 		return fmt.Errorf("line %d: expected key: value, got %q", lineNo, kv)
 	}
 	key = strings.TrimSpace(key)
 	value = strings.TrimSpace(value)
 	value = unquoteYAML(value)
 	switch key {
 	case "name":
 		l.Name = value
 	case "url":
 		l.URL = value
 	case "token":
 		l.Token = value
 	case "default":
 		l.Default = value == "true"
 	}
 	return nil
 }
 // unquoteYAML 剝除 YAML 的單／雙引號。
 func unquoteYAML(s string) string {
 	if len(s) >= 2 {
 		if (s[0] == '"' && s[len(s)-1] == '"') || (s[0] == '\'' && s[len(s)-1] == '\'') {
 			return s[1 : len(s)-1]
 		}
 	}
 	return s
 }
 // hostOf 取 URL 的主機部分（連埠）；解析失敗回空字串。
 func hostOf(rawURL string) string {
 	s := strings.TrimSpace(rawURL)
 	if s == "" {
 		return ""
 	}
 	// 補配置讓 url.Parse 能取 Host。
 	if !strings.Contains(s, "://") {
 		s = "https://" + s
 	}
 	u, err := url.Parse(s)
 	if err != nil {
 		return ""
 	}
 	return strings.ToLower(u.Host)
 }
@@ -1,181 +0,0 @@
 // auth_test.go 驗證認證來源選序（--token → TEAI_TOKEN → tea 組態）
 // 與 tea 組態解析。
 package gitea
 import (
 	"errors"
 	"testing"
 )
 // fakeEnv 依 map 回傳環境變數。
 func fakeEnv(m map[string]string) EnvLookup {
 	return func(key string) (string, bool) {
 		v, ok := m[key]
 		return v, ok
 	}
 }
 // fakeReadFile 依 map 回傳檔案內容；不存在時回 os.ErrNotExist 類錯誤。
 func fakeReadFile(m map[string]string) ReadFileFunc {
 	return func(path string) ([]byte, error) {
 		if data, ok := m[path]; ok {
 			return []byte(data), nil
 		}
 		return nil, errors.New("file does not exist")
 	}
 }
 const sampleTeaConfig = `logins:
    - name: other.example.com
      url: https://other.example.com
      token: other-token
      default: false
    - name: gitea.alterminal.com
      url: https://gitea.alterminal.com
      token: site-token
      default: true
 preferences:
    editor: false
 `
 func TestResolveTokenOrdering(t *testing.T) {
 	base := AuthOptions{
 		SiteURL: "https://gitea.alterminal.com",
 		Env:     fakeEnv(nil),
 		ReadFile: fakeReadFile(map[string]string{
 			"/cfg/config.yml": sampleTeaConfig,
 		}),
 		ConfigPath: "/cfg/config.yml",
 	}
 	t.Run("flag wins over env and config", func(t *testing.T) {
 		opts := base
 		opts.FlagToken = "flag-token"
 		opts.Env = fakeEnv(map[string]string{"TEAI_TOKEN": "env-token"})
 		tok, src, err := ResolveToken(opts)
 		if err != nil || tok != "flag-token" || src != SourceFlag {
 			t.Fatalf("want flag-token/flag, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 	t.Run("env wins over config", func(t *testing.T) {
 		opts := base
 		opts.Env = fakeEnv(map[string]string{"TEAI_TOKEN": "env-token"})
 		tok, src, err := ResolveToken(opts)
 		if err != nil || tok != "env-token" || src != SourceEnv {
 			t.Fatalf("want env-token/env, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 	t.Run("tea config used when flag and env absent", func(t *testing.T) {
 		opts := base
 		tok, src, err := ResolveToken(opts)
 		if err != nil || tok != "site-token" || src != SourceTeaConfig {
 			t.Fatalf("want site-token/tea-config, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 	t.Run("none when all sources absent", func(t *testing.T) {
 		opts := base
 		opts.ConfigPath = "/cfg/missing.yml"
 		tok, src, err := ResolveToken(opts)
 		if err != nil || tok != "" || src != SourceNone {
 			t.Fatalf("want \"\"/none, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 	t.Run("blank env var is skipped", func(t *testing.T) {
 		opts := base
 		opts.Env = fakeEnv(map[string]string{"TEAI_TOKEN": "   "})
 		tok, src, err := ResolveToken(opts)
 		if err != nil || tok != "site-token" || src != SourceTeaConfig {
 			t.Fatalf("want site-token/tea-config, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 	t.Run("blank flag is skipped", func(t *testing.T) {
 		opts := base
 		opts.FlagToken = "  "
 		opts.Env = fakeEnv(map[string]string{"TEAI_TOKEN": "env-token"})
 		tok, src, err := ResolveToken(opts)
 		if err != nil || tok != "env-token" || src != SourceEnv {
 			t.Fatalf("want env-token/env, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 	t.Run("TEA_CONFIG points config path", func(t *testing.T) {
 		opts := base
 		opts.ConfigPath = "" // 不用 --config，改用 TEA_CONFIG
 		opts.Env = fakeEnv(map[string]string{
 			"TEA_CONFIG": "/cfg/config.yml",
 		})
 		tok, src, err := ResolveToken(opts)
 		if err != nil || tok != "site-token" || src != SourceTeaConfig {
 			t.Fatalf("want site-token/tea-config via TEA_CONFIG, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 	t.Run("explicit --config beats TEA_CONFIG", func(t *testing.T) {
 		opts := base // ConfigPath = /cfg/config.yml（有 site-token）
 		opts.Env = fakeEnv(map[string]string{
 			"TEA_CONFIG": "/cfg/other.yml",
 		})
 		read := fakeReadFile(map[string]string{
 			"/cfg/config.yml": sampleTeaConfig,
 			"/cfg/other.yml":  "logins:\n    - name: x\n      url: https://gitea.alterminal.com\n      token: other\n      default: true\n",
 		})
 		opts.ReadFile = read
 		tok, src, err := ResolveToken(opts)
 		if err != nil || tok != "site-token" || src != SourceTeaConfig {
 			t.Fatalf("want site-token from explicit config, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 }
 func TestParseTeaConfigPicksMatchingLogin(t *testing.T) {
 	t.Run("host match preferred over default", func(t *testing.T) {
 		cfg := `logins:
    - name: other
      url: https://other.example.com
      token: wrong-token
      default: true
    - name: target
      url: https://gitea.alterminal.com
      token: right-token
      default: false
 `
 		login, err := parseTeaConfig([]byte(cfg), "https://gitea.alterminal.com")
 		if err != nil {
 			t.Fatalf("parse error: %v", err)
 		}
 		if login.Token != "right-token" {
 			t.Fatalf("host-matched login should win, got token %q", login.Token)
 		}
 	})
 	t.Run("quoted token unquoted", func(t *testing.T) {
 		cfg := "logins:\n    - name: t\n      url: https://gitea.alterminal.com\n      token: \"quoted-token\"\n      default: true\n"
 		login, err := parseTeaConfig([]byte(cfg), "https://gitea.alterminal.com")
 		if err != nil {
 			t.Fatalf("parse error: %v", err)
 		}
 		if login.Token != "quoted-token" {
 			t.Fatalf("want quoted-token (unquoted), got %q", login.Token)
 		}
 	})
 	t.Run("malformed login entry errors", func(t *testing.T) {
 		cfg := "logins:\n    - name: t\n      url: https://gitea.alterminal.com\n      oops\n"
 		if _, err := parseTeaConfig([]byte(cfg), ""); err == nil {
 			t.Fatal("malformed line should error")
 		}
 	})
 	t.Run("no logins yields empty", func(t *testing.T) {
 		cfg := "preferences:\n    editor: false\n"
 		login, err := parseTeaConfig([]byte(cfg), "")
 		if err != nil || login.Token != "" {
 			t.Fatalf("want empty login, got %+v (err %v)", login, err)
 		}
 	})
 }
@@ -1,183 +0,0 @@
 // 套件 gitea 提供存取 Gitea API 的 HTTP 用戶端基礎：
 // 認證、分頁、逾時與錯誤映射。
 //
 // 僅使用標準庫（net/http 等），離線可建置。token 由呼叫端注入，
 // 本套件不負責認證來源的解析（見 auth.go），也不會把 token 寫進
 // 任何輸出或錯誤訊息。
 package gitea
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"reflect"
 	"strconv"
 	"strings"
 	"time"
 )
 // ErrAPI 表示與 Gitea API 溝通失敗（連線、認證、權限或伺服器錯誤）。
 // 行為上對應結束碼 3（API 錯誤）。
 type ErrAPI struct {
 	// StatusCode 是 HTTP 回應狀態碼；0 表示請求未完成（連線失敗等）。
 	StatusCode int
 	// Op 是失敗的步驟描述（如 "GET /api/v1/user"），僅供診斷。
 	Op string
 	// Err 是底層錯誤。
 	Err error
 }
 // Error 實作 error 介面；不包含 token 或完整回應內容。
 func (e *ErrAPI) Error() string {
 	if e.StatusCode == 0 {
 		return fmt.Sprintf("gitea: %s: %v", e.Op, e.Err)
 	}
 	return fmt.Sprintf("gitea: %s: HTTP %d", e.Op, e.StatusCode)
 }
 // Unwrap 支援 errors.Is / errors.As。
 func (e *ErrAPI) Unwrap() error { return e.Err }
 // Client 是 Gitea API 的最小用戶端。零值不可用，請用 New。
 type Client struct {
 	// baseURL 是 API 根（如 https://gitea.alterminal.com/api/v1），
 	// 不帶尾斜線。
 	baseURL *url.URL
 	// token 是 API token；空字串表示匿名存取（公開端點）。
 	token string
 	// hc 是底層 HTTP 用戶端（帶逾時）。
 	hc *http.Client
 }
 // DefaultTimeout 是未指定逾時時的預設值。
 const DefaultTimeout = 30 * time.Second
 // New 建立用戶端。baseURL 為站點網址（如 https://gitea.alterminal.com），
 // 函式內部自行補上 /api/v1 路徑。timeout <= 0 時採 DefaultTimeout。
 func New(baseURL, token string, timeout time.Duration) (*Client, error) {
 	u, err := url.Parse(strings.TrimSuffix(baseURL, "/"))
 	if err != nil || u.Scheme == "" || u.Host == "" {
 		return nil, fmt.Errorf("gitea: invalid base URL %q", baseURL)
 	}
 	u = u.JoinPath("api", "v1")
 	if timeout <= 0 {
 		timeout = DefaultTimeout
 	}
 	return &Client{
 		baseURL: u,
 		token:   token,
 		hc:      &http.Client{Timeout: timeout},
 	}, nil
 }
 // MaxLimit 是 Gitea 清單端點單次回傳上限（服務端硬上限 50）。
 const MaxLimit = 50
 // getJSON 對 path（相對 baseURL，以 / 開頭）發 GET，把 JSON 回應解到 out。
 // 失敗時回傳 *ErrAPI。rawQuery 為組好的查詢字串（見 ListOptions.query）。
 func (c *Client) getJSON(ctx context.Context, path, rawQuery string, out any) error {
 	u := *c.baseURL
 	u.Path += path
 	u.RawQuery = rawQuery
 	op := "GET " + u.Path
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
 	if err != nil {
 		return &ErrAPI{Op: op, Err: err}
 	}
 	req.Header.Set("Accept", "application/json")
 	if c.token != "" {
 		req.Header.Set("Authorization", "token "+c.token)
 	}
 	resp, err := c.hc.Do(req)
 	if err != nil {
 		return &ErrAPI{Op: op, Err: err}
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode < 200 || resp.StatusCode > 299 {
 		// 把內容讀掉再丟棄，讓連線可重用；錯誤訊息不含回應內容。
 		_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 4096))
 		return &ErrAPI{Op: op, StatusCode: resp.StatusCode}
 	}
 	if out == nil {
 		return nil
 	}
 	if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
 		return &ErrAPI{Op: op, Err: fmt.Errorf("decode response: %w", err)}
 	}
 	return nil
 }
 // GetJSON 是 getJSON 的公開介面，供非清單端點（如 /user）使用。
 func (c *Client) GetJSON(ctx context.Context, path string, out any) error {
 	return c.getJSON(ctx, path, "", out)
 }
 // ListOptions 描述清單端點的分頁參數。
 type ListOptions struct {
 	// Limit 是單頁筆數；<= 0 或 > MaxLimit 時設為 MaxLimit。
 	Limit int
 	// Page 是頁碼（1 起）；僅供單頁抓取，ListAll 一律從第 1 頁開始。
 	Page int
 	// Extra 是額外查詢參數（如 state、type）。
 	Extra url.Values
 }
 // query 把分頁參數組成查詢字串。
 func (o ListOptions) query() string {
 	q := url.Values{}
 	limit := o.Limit
 	if limit <= 0 || limit > MaxLimit {
 		limit = MaxLimit
 	}
 	q.Set("limit", strconv.Itoa(limit))
 	if o.Page > 1 {
 		q.Set("page", strconv.Itoa(o.Page))
 	}
 	for k, vs := range o.Extra {
 		for _, v := range vs {
 			q.Set(k, v)
 		}
 	}
 	return q.Encode()
 }
 // ListAll 逐頁抓取清單端點直到抓完，把結果存進 out（指向 slice 的指標，
 // 初始須為空 slice）。每頁固定使用 limit=MaxLimit（Gitea 上限 50）；
 // opts.Extra 照常帶入。頁數在服務端回傳未滿頁或空頁時結束。
 func (c *Client) ListAll(ctx context.Context, path string, opts ListOptions, out any) error {
 	rv := reflect.ValueOf(out)
 	if rv.Kind() != reflect.Pointer || rv.IsNil() {
 		return fmt.Errorf("gitea: ListAll: out must be non-nil pointer to slice")
 	}
 	sv := rv.Elem()
 	if sv.Kind() != reflect.Slice {
 		return fmt.Errorf("gitea: ListAll: out must be non-nil pointer to slice")
 	}
 	if sv.Len() != 0 {
 		return fmt.Errorf("gitea: ListAll: out slice must be empty")
 	}
 	for page := 1; ; page++ {
 		opts := opts
 		opts.Limit = MaxLimit
 		opts.Page = page
 		pageOut := reflect.MakeSlice(sv.Type(), 0, MaxLimit)
 		pp := reflect.New(sv.Type())
 		pp.Elem().Set(pageOut)
 		if err := c.getJSON(ctx, path, opts.query(), pp.Interface()); err != nil {
 			return err
 		}
 		got := pp.Elem()
 		n := got.Len()
 		if n == 0 {
 			return nil
 		}
 		sv.Set(reflect.AppendSlice(sv, got))
 		if n < MaxLimit {
 			return nil
 		}
 	}
 }
@@ -1,195 +0,0 @@
 // client_test.go 用 httptest 伺服器驗證用戶端行為：分頁（limit=50）、
 // 認證表頭、逾時與錯誤映射（連線失敗、401、5xx → *ErrAPI）。
 package gitea
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"sync/atomic"
 	"testing"
 	"time"
 )
 // newTestClient 對 srv 建立用戶端。
 func newTestClient(srvURL, token string, timeout time.Duration) (*Client, error) {
 	return New(srvURL, token, timeout)
 }
 func TestNewRejectsInvalidBaseURL(t *testing.T) {
 	for _, bad := range []string{"", "not a url", "http://"} {
 		if _, err := New(bad, "", 0); err == nil {
 			t.Errorf("New(%q) should fail", bad)
 		}
 	}
 }
 func TestClientSendsTokenHeader(t *testing.T) {
 	var gotAuth atomic.Value
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		gotAuth.Store(r.Header.Get("Authorization"))
 		fmt.Fprint(w, `{"login":"max"}`)
 	}))
 	defer srv.Close()
 	c, err := newTestClient(srv.URL, "secret-token", time.Second)
 	if err != nil {
 		t.Fatal(err)
 	}
 	var out map[string]any
 	if err := c.GetJSON(context.Background(), "/user", &out); err != nil {
 		t.Fatal(err)
 	}
 	if got := gotAuth.Load(); got != "token secret-token" {
 		t.Fatalf("Authorization header = %v, want token secret-token", got)
 	}
 }
 func TestErrAPIMessageHasNoToken(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusUnauthorized)
 	}))
 	defer srv.Close()
 	c, err := newTestClient(srv.URL, "secret-token", time.Second)
 	if err != nil {
 		t.Fatal(err)
 	}
 	err = c.GetJSON(context.Background(), "/user", nil)
 	var apiErr *ErrAPI
 	if !errors.As(err, &apiErr) {
 		t.Fatalf("want *ErrAPI, got %v", err)
 	}
 	if apiErr.StatusCode != http.StatusUnauthorized {
 		t.Fatalf("status = %d, want 401", apiErr.StatusCode)
 	}
 	if got := apiErr.Error(); got == "" || contains(got, "secret-token") {
 		t.Fatalf("error message must not leak token, got %q", got)
 	}
 }
 func TestListAllPaginatesWithLimitFifty(t *testing.T) {
 	var calls int32
 	var limits []int32
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		atomic.AddInt32(&calls, 1)
 		limit := int32(0)
 		fmt.Sscanf(r.URL.Query().Get("limit"), "%d", &limit)
 		limits = append(limits, limit)
 		page := 1
 		fmt.Sscanf(r.URL.Query().Get("page"), "%d", &page)
 		// 第 1、2 頁各滿 50 筆，第 3 頁 10 筆後結束。
 		total := 110
 		start := (page - 1) * 50
 		end := start + 50
 		if end > total {
 			end = total
 		}
 		w.Header().Set("Content-Type", "application/json")
 		if start >= total {
 			fmt.Fprint(w, "[]")
 			return
 		}
 		items := make([]int, 0, end-start)
 		for i := start; i < end; i++ {
 			items = append(items, i)
 		}
 		_ = json.NewEncoder(w).Encode(items)
 	}))
 	defer srv.Close()
 	c, err := newTestClient(srv.URL, "", time.Second)
 	if err != nil {
 		t.Fatal(err)
 	}
 	var got []int
 	if err := c.ListAll(context.Background(), "/things", ListOptions{}, &got); err != nil {
 		t.Fatal(err)
 	}
 	if len(got) != 110 {
 		t.Fatalf("want 110 items, got %d", len(got))
 	}
 	for i, v := range got {
 		if v != i {
 			t.Fatalf("item %d = %d, want %d", i, v, i)
 		}
 	}
 	if n := atomic.LoadInt32(&calls); n != 3 {
 		t.Fatalf("want 3 page requests, got %d", n)
 	}
 	for i, l := range limits {
 		if l != 50 {
 			t.Fatalf("page %d limit = %d, want 50", i+1, l)
 		}
 	}
 }
 func TestListAllRejectsBadOut(t *testing.T) {
 	c, err := newTestClient("https://gitea.alterminal.com", "", time.Second)
 	if err != nil {
 		t.Fatal(err)
 	}
 	var notSlice int
 	if err := c.ListAll(context.Background(), "/x", ListOptions{}, &notSlice); err == nil {
 		t.Fatal("non-slice out should error")
 	}
 	preloaded := []int{1}
 	if err := c.ListAll(context.Background(), "/x", ListOptions{}, &preloaded); err == nil {
 		t.Fatal("non-empty out should error")
 	}
 }
 func TestClientTimeoutSurfacesAsErrAPI(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		time.Sleep(200 * time.Millisecond)
 		fmt.Fprint(w, `{}`)
 	}))
 	defer srv.Close()
 	c, err := newTestClient(srv.URL, "", 50*time.Millisecond)
 	if err != nil {
 		t.Fatal(err)
 	}
 	err = c.GetJSON(context.Background(), "/user", nil)
 	var apiErr *ErrAPI
 	if !errors.As(err, &apiErr) {
 		t.Fatalf("timeout should surface as *ErrAPI, got %v", err)
 	}
 	if apiErr.StatusCode != 0 {
 		t.Fatalf(" StatusCode should be 0 for transport error, got %d", apiErr.StatusCode)
 	}
 }
 func TestClientServerFiveHundred(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusInternalServerError)
 	}))
 	defer srv.Close()
 	c, err := newTestClient(srv.URL, "", time.Second)
 	if err != nil {
 		t.Fatal(err)
 	}
 	err = c.GetJSON(context.Background(), "/user", nil)
 	var apiErr *ErrAPI
 	if !errors.As(err, &apiErr) || apiErr.StatusCode != 500 {
 		t.Fatalf("want *ErrAPI with 500, got %v", err)
 	}
 }
 // contains 是簡單子字串檢查（避免只為此引入 strings 到測試以外的地方）。
 func contains(s, sub string) bool {
 	return len(s) >= len(sub) && (s == sub || len(sub) == 0 || indexOf(s, sub) >= 0)
 }
 func indexOf(s, sub string) int {
 	for i := 0; i+len(sub) <= len(s); i++ {
 		if s[i:i+len(sub)] == sub {
 			return i
 		}
 	}
 	return -1
 }
@@ -1,421 +0,0 @@
 // config.go — tea 相容登入組態的讀取與行級編輯。
 //
 // teai 與 tea 共用同一份組態檔（README 設計原則 5），因此寫入採「行級編輯」：
 // 只修改目標登入項目的所屬行，其餘內容（未知欄位、註解、preferences 區段、
 // 空行與縮排）逐字保留，避免改壞 tea 也在使用的檔案。新增項目依 tea 實際
 // 寫出的欄位順序輸出，讓檔案外觀與 tea 一致。
 //
 // token 值只會進出這個套件的資料結構與組態檔本身，永遠不出現在錯誤訊息。
 package gitea
 import (
 	"fmt"
 	"os"
 	"path/filepath"
 	"regexp"
 	"slices"
 	"strconv"
 	"strings"
 )
 // LoginEntry 是組態檔中的一筆登入資料（編輯用，含 tea 的 user 欄位）。
 type LoginEntry struct {
 	Name    string
 	URL     string
 	Token   string
 	Default bool
 	User    string
 }
 // loginItemSpan 標記 logins 清單中一個項目在檔案中的行範圍 [start, end)。
 type loginItemSpan struct {
 	name  string
 	start int
 	end   int
 }
 // configDoc 是解析後的組態檔：原始行與 logins 項目的位置資訊。
 type configDoc struct {
 	lines        []string
 	items        []loginItemSpan
 	loginsHeader int    // 「logins:」所在行；-1 表示沒有
 	itemIndent   string // 項目行的縮排（取第一個項目）；預設四格空白
 }
 // parseConfigDoc 掃描組態內容，定位 logins 清單與各項目的行範圍。
 // 只認識 tea 實際寫出的格式：頂層 `logins:` 加縮排的 `- key: value` 項目；
 // 其餘行原樣保留在 lines 中。
 func parseConfigDoc(data []byte) configDoc {
 	doc := configDoc{lines: splitLines(data), loginsHeader: -1, itemIndent: "    "}
 	inLogins := false
 	cur := -1
 	for i, raw := range doc.lines {
 		line := raw
 		trimmed := strings.TrimSpace(line)
 		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
 			continue
 		}
 		indent := line[:len(line)-len(strings.TrimLeft(line, " "))]
 		if indent == "" {
 			if inLogins && doc.loginsHeader >= 0 {
 				// 離開 logins 區段；listEnd 由最後一個項目的 end 決定，這裡不用記。
 			}
 			inLogins = strings.HasPrefix(trimmed, "logins:")
 			if inLogins && doc.loginsHeader < 0 {
 				doc.loginsHeader = i
 			}
 			cur = -1
 			continue
 		}
 		if !inLogins {
 			continue
 		}
 		if strings.HasPrefix(trimmed, "- ") || trimmed == "-" {
 			if cur >= 0 {
 				doc.items[cur].end = i
 			}
 			doc.items = append(doc.items, loginItemSpan{start: i, end: i + 1})
 			cur = len(doc.items) - 1
 			if len(doc.items) == 1 {
 				doc.itemIndent = indent
 			}
 			if rest := strings.TrimSpace(strings.TrimPrefix(trimmed, "-")); rest != "" {
 				if key, value, ok := strings.Cut(rest, ":"); ok && strings.TrimSpace(key) == "name" {
 					doc.items[cur].name = unquoteYAML(strings.TrimSpace(value))
 				}
 			}
 			continue
 		}
 		if cur >= 0 {
 			doc.items[cur].end = i + 1
 		}
 	}
 	return doc
 }
 // findItem 依名稱找項目；找不到回 -1。
 func (d configDoc) findItem(name string) int {
 	for i, it := range d.items {
 		if it.name == name {
 			return i
 		}
 	}
 	return -1
 }
 // fieldIndent 回傳項目內屬性行的縮排（項目縮排 + 兩格，tea 的格式）。
 func (d configDoc) fieldIndent() string {
 	return d.itemIndent + "  "
 }
 // entryAt 取某個項目的完整欄位值。
 func (d configDoc) entryAt(it loginItemSpan) LoginEntry {
 	var e LoginEntry
 	apply := func(kv string) {
 		key, value, ok := strings.Cut(kv, ":")
 		if !ok {
 			return
 		}
 		key = strings.TrimSpace(key)
 		value = unquoteYAML(strings.TrimSpace(value))
 		switch key {
 		case "name":
 			e.Name = value
 		case "url":
 			e.URL = value
 		case "token":
 			e.Token = value
 		case "default":
 			e.Default = value == "true"
 		case "user":
 			e.User = value
 		}
 	}
 	first := strings.TrimSpace(d.lines[it.start])
 	if rest := strings.TrimSpace(strings.TrimPrefix(first, "-")); rest != "" {
 		apply(rest)
 	}
 	for i := it.start + 1; i < it.end; i++ {
 		if kv := strings.TrimSpace(d.lines[i]); kv != "" && !strings.HasPrefix(kv, "#") {
 			apply(kv)
 		}
 	}
 	return e
 }
 // ListLogins 回傳組態內容中的所有登入（依檔案順序）。
 func ListLogins(data []byte) []LoginEntry {
 	doc := parseConfigDoc(data)
 	out := make([]LoginEntry, 0, len(doc.items))
 	for _, it := range doc.items {
 		out = append(out, doc.entryAt(it))
 	}
 	return out
 }
 // ListLoginsFile 讀取組態檔並列出登入；檔案不存在視為空清單（非錯誤）。
 func ListLoginsFile(path string) ([]LoginEntry, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil, nil
 		}
 		return nil, err
 	}
 	return ListLogins(data), nil
 }
 // UpsertLogin 新增或更新名為 e.Name 的登入。
 //
 // 已存在則就地更新 url/token/user/default（保留其他欄位與行）；不存在則
 // 依 tea 的欄位順序插入新項目。makeDefault 為 true 時將其設為預設並取消
 // 其他登入的預設旗標；新增後若成為唯一登入也自動成為預設。
 // 回傳新內容與最終生效的項目值。
 func UpsertLogin(data []byte, e LoginEntry, makeDefault bool) ([]byte, LoginEntry, error) {
 	if strings.TrimSpace(e.Name) == "" {
 		return nil, LoginEntry{}, fmt.Errorf("gitea: login name must not be empty")
 	}
 	if strings.TrimSpace(e.URL) == "" {
 		return nil, LoginEntry{}, fmt.Errorf("gitea: login url must not be empty")
 	}
 	if e.Token == "" {
 		return nil, LoginEntry{}, fmt.Errorf("gitea: login token must not be empty")
 	}
 	doc := parseConfigDoc(data)
 	idx := doc.findItem(e.Name)
 	if idx >= 0 {
 		existing := doc.entryAt(doc.items[idx])
 		wantDefault := existing.Default || makeDefault
 		it := doc.items[idx]
 		lines := doc.lines
 		// 就地替換各欄位；缺少的欄位補在項目結尾。
 		for _, kv := range []struct{ key, value string }{
 			{"name", yamlScalar(e.Name)},
 			{"url", yamlScalar(e.URL)},
 			{"token", yamlScalar(e.Token)},
 			{"user", yamlScalar(e.User)},
 			{"default", strconv.FormatBool(wantDefault)},
 		} {
 			lines = setFieldInItem(lines, it, kv.key, kv.value, doc.fieldIndent())
 		}
 		out := joinLines(lines)
 		if wantDefault {
 			var err error
 			out, err = SetDefaultLogin(out, e.Name)
 			if err != nil {
 				return nil, LoginEntry{}, err
 			}
 		}
 		final := existing
 		final.URL, final.Token, final.User = e.URL, e.Token, e.User
 		final.Default = wantDefault
 		return out, final, nil
 	}
 	// 新增項目。
 	wantDefault := makeDefault || len(doc.items) == 0
 	block := newLoginBlock(doc.itemIndent, e.Name, e.URL, e.Token, wantDefault, e.User)
 	var lines []string
 	var insertAt int
 	if doc.loginsHeader < 0 {
 		if len(doc.lines) == 0 {
 			lines = []string{"logins:"}
 		} else {
 			lines = append(slices.Clone(doc.lines), "", "logins:")
 		}
 		insertAt = len(lines)
 	} else {
 		lines = slices.Clone(doc.lines)
 		// 「logins: []」是空清單的串流寫法，直接接項目會變無效 YAML；改回區段寫法。
 		if len(doc.items) == 0 && strings.TrimSpace(lines[doc.loginsHeader]) == "logins: []" {
 			lines[doc.loginsHeader] = "logins:"
 		}
 		if len(doc.items) > 0 {
 			insertAt = doc.items[len(doc.items)-1].end
 		} else {
 			insertAt = doc.loginsHeader + 1
 		}
 	}
 	out := append(slices.Clone(lines[:insertAt]), block...)
 	out = append(out, lines[insertAt:]...)
 	data2 := joinLines(out)
 	if wantDefault {
 		var err error
 		data2, err = SetDefaultLogin(data2, e.Name)
 		if err != nil {
 			return nil, LoginEntry{}, err
 		}
 	}
 	return data2, LoginEntry{
 		Name:    e.Name,
 		URL:     e.URL,
 		Token:   e.Token,
 		Default: wantDefault,
 		User:    e.User,
 	}, nil
 }
 // SetDefaultLogin 把名為 name 的登入設為預設，其餘一律取消預設。
 func SetDefaultLogin(data []byte, name string) ([]byte, error) {
 	doc := parseConfigDoc(data)
 	idx := doc.findItem(name)
 	if idx < 0 {
 		return nil, fmt.Errorf("gitea: login %q not found", name)
 	}
 	lines := doc.lines
 	// 反序處理：前面的插入不影響後面已算好的行範圍，這裡的反序則保證
 	// 後方項目的插入/修改不會推移前方項目的範圍。
 	for i := len(doc.items) - 1; i >= 0; i-- {
 		want := "false"
 		if i == idx {
 			want = "true"
 		}
 		lines = setFieldInItem(lines, doc.items[i], "default", want, doc.fieldIndent())
 	}
 	return joinLines(lines), nil
 }
 // RemoveLogin 移除名為 name 的登入。若被移除者是預設且還有其他登入，
 // 剩下的第一筆自動遞補為預設。回傳新內容與遞補後的預設名稱（無則空字串）。
 func RemoveLogin(data []byte, name string) ([]byte, string, error) {
 	doc := parseConfigDoc(data)
 	idx := doc.findItem(name)
 	if idx < 0 {
 		return nil, "", fmt.Errorf("gitea: login %q not found", name)
 	}
 	removed := doc.entryAt(doc.items[idx])
 	it := doc.items[idx]
 	lines := slices.Delete(slices.Clone(doc.lines), it.start, it.end)
 	out := joinLines(lines)
 	promoted := ""
 	if removed.Default {
 		rest := ListLogins(out)
 		if len(rest) > 0 {
 			promoted = rest[0].Name
 			var err error
 			out, err = SetDefaultLogin(out, promoted)
 			if err != nil {
 				return nil, "", err
 			}
 		}
 	}
 	return out, promoted, nil
 }
 // setFieldInItem 把項目內 key 的值換成 value，保留該行的原始縮排；
 // key 不存在時以 fieldIndent 插在項目結尾。回傳新的行切片。
 func setFieldInItem(lines []string, it loginItemSpan, key, value, fieldIndent string) []string {
 	first := lines[it.start]
 	trimmed := strings.TrimSpace(first)
 	if rest := strings.TrimSpace(strings.TrimPrefix(trimmed, "-")); rest != "" {
 		if k, _, ok := strings.Cut(rest, ":"); ok && strings.TrimSpace(k) == key {
 			prefix := first[:strings.Index(first, "-")] + "- "
 			lines[it.start] = prefix + key + ": " + value
 			return lines
 		}
 	}
 	for i := it.start + 1; i < it.end; i++ {
 		t := strings.TrimSpace(lines[i])
 		if k, _, ok := strings.Cut(t, ":"); ok && strings.TrimSpace(k) == key {
 			indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " "))]
 			lines[i] = indent + key + ": " + value
 			return lines
 		}
 	}
 	out := append(slices.Clone(lines[:it.end]), fieldIndent+key+": "+value)
 	return append(out, lines[it.end:]...)
 }
 // newLoginBlock 產生 tea 格式的新登入項目（欄位順序與 tea 實際寫出的一致）。
 func newLoginBlock(itemIndent, name, url, token string, isDefault bool, user string) []string {
 	f := itemIndent + "  "
 	return []string{
 		itemIndent + "- name: " + yamlScalar(name),
 		f + "url: " + yamlScalar(url),
 		f + "token: " + yamlScalar(token),
 		f + "default: " + strconv.FormatBool(isDefault),
 		f + `ssh_host: ""`,
 		f + `ssh_key: ""`,
 		f + "insecure: false",
 		f + `ssh_certificate_principal: ""`,
 		f + "ssh_agent: false",
 		f + `ssh_key_agent_pub: ""`,
 		f + "version_check: false",
 		f + "user: " + yamlScalar(user),
 		f + "created: 0",
 	}
 }
 // plainScalar 是可以不加引號直接寫出的 YAML 純量。
 var plainScalar = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._:/~+=@-]*$`)
 // yamlScalar 把值寫成 YAML 純量：安全字元集直接輸出，其餘加雙引號。
 func yamlScalar(s string) string {
 	if plainScalar.MatchString(s) {
 		return s
 	}
 	return strconv.Quote(s)
 }
 // HostOf 取 URL 的主機部分（連埠，小寫）；解析失敗回空字串。
 // 供比對「同一站點」的登入時使用。
 func HostOf(rawURL string) string { return hostOf(rawURL) }
 // splitLines 把內容拆成行（去掉行尾換行與 CR）。
 func splitLines(data []byte) []string {
 	if len(data) == 0 {
 		return nil
 	}
 	s := strings.TrimSuffix(string(data), "\n")
 	if s == "" {
 		return []string{""}
 	}
 	return strings.Split(s, "\n")
 }
 // joinLines 把行組回內容，保證以單一換行結尾。
 func joinLines(lines []string) []byte {
 	if len(lines) == 0 {
 		return nil
 	}
 	s := strings.Join(lines, "\n")
 	if !strings.HasSuffix(s, "\n") {
 		s += "\n"
 	}
 	return []byte(s)
 }
 // SaveTeaConfigFile 把組態內容原子寫入 path：先寫同目錄暫存檔（0600），
 // 再 rename 取代，避免半寫入狀態。必要時建立上層目錄（0700）。
 func SaveTeaConfigFile(path string, data []byte) error {
 	dir := filepath.Dir(path)
 	if err := os.MkdirAll(dir, 0o700); err != nil {
 		return fmt.Errorf("gitea: create config dir: %w", err)
 	}
 	tmp, err := os.CreateTemp(dir, ".config-*.yml")
 	if err != nil {
 		return fmt.Errorf("gitea: create temp file: %w", err)
 	}
 	tmpName := tmp.Name()
 	defer func() {
 		if tmpName != "" {
 			_ = os.Remove(tmpName)
 		}
 	}()
 	if _, err := tmp.Write(data); err != nil {
 		tmp.Close()
 		return fmt.Errorf("gitea: write temp file: %w", err)
 	}
 	if err := tmp.Chmod(0o600); err != nil {
 		tmp.Close()
 		return fmt.Errorf("gitea: chmod temp file: %w", err)
 	}
 	if err := tmp.Close(); err != nil {
 		return fmt.Errorf("gitea: close temp file: %w", err)
 	}
 	if err := os.Rename(tmpName, path); err != nil {
 		return fmt.Errorf("gitea: rename config: %w", err)
 	}
 	tmpName = "" // 已改名成功，不必清理。
 	return nil
 }
@@ -1,263 +0,0 @@
 // config_test.go 驗證 tea 相容組態的行級編輯：新增、更新、設預設、
 // 移除，以及「未知欄位與其他區段逐字保留」的關鍵性質。
 package gitea
 import (
 	"bytes"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 )
 // realWorldTeaConfig 是 tea 實際寫出的組態（含 ssh_* 等未知欄位與 preferences）。
 const realWorldTeaConfig = `logins:
    - name: alterminal
      url: https://gitea.alterminal.com
      token: tok-1
      default: true
      ssh_host: ""
      ssh_key: ""
      insecure: false
      ssh_certificate_principal: ""
      ssh_agent: false
      ssh_key_agent_pub: ""
      version_check: false
      user: ceo
      created: 0
 preferences:
    editor: false
    flag_defaults:
        remote: ""
 `
 func TestListLoginsParsesAllEntries(t *testing.T) {
 	logins := ListLogins([]byte(realWorldTeaConfig))
 	if len(logins) != 1 {
 		t.Fatalf("want 1 login, got %d", len(logins))
 	}
 	l := logins[0]
 	if l.Name != "alterminal" || l.URL != "https://gitea.alterminal.com" || l.Token != "tok-1" || !l.Default || l.User != "ceo" {
 		t.Fatalf("unexpected entry: %+v", l)
 	}
 }
 func TestUpsertLoginUpdatesExistingPreservesRest(t *testing.T) {
 	out, final, err := UpsertLogin([]byte(realWorldTeaConfig), LoginEntry{
 		Name: "alterminal", URL: "https://gitea.alterminal.com", Token: "tok-2", User: "ceo",
 	}, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	s := string(out)
 	// 更新 token、保留其他欄位。
 	if !strings.Contains(s, "token: tok-2") || strings.Contains(s, "tok-1") {
 		t.Fatalf("token not updated:\n%s", s)
 	}
 	for _, want := range []string{
 		"ssh_host: \"\"", "insecure: false", "ssh_key_agent_pub: \"\"",
 		"user: ceo", "created: 0", "default: true",
 		"preferences:", "editor: false", "flag_defaults:", `remote: ""`,
 	} {
 		if !strings.Contains(s, want) {
 			t.Fatalf("missing %q after edit:\n%s", want, s)
 		}
 	}
 	if final.Default != true {
 		t.Fatalf("existing default should stay default, got %+v", final)
 	}
 	// 編輯後仍可解析出正確值。
 	logins := ListLogins(out)
 	if len(logins) != 1 || logins[0].Token != "tok-2" || !logins[0].Default {
 		t.Fatalf("reparse mismatch: %+v", logins)
 	}
 }
 func TestUpsertLoginAppendsNewAndMakesDefault(t *testing.T) {
 	out, final, err := UpsertLogin([]byte(realWorldTeaConfig), LoginEntry{
 		Name: "second", URL: "https://git.example.com", Token: "tok-b", User: "bob",
 	}, true)
 	if err != nil {
 		t.Fatal(err)
 	}
 	logins := ListLogins(out)
 	if len(logins) != 2 {
 		t.Fatalf("want 2 logins, got %d:\n%s", len(logins), out)
 	}
 	if logins[0].Default || !logins[1].Default {
 		t.Fatalf("only the new login should be default: %+v", logins)
 	}
 	if logins[1].Name != "second" || logins[1].Token != "tok-b" || logins[1].User != "bob" {
 		t.Fatalf("new entry mismatch: %+v", logins[1])
 	}
 	if !final.Default {
 		t.Fatalf("final should be default: %+v", final)
 	}
 	// tea 的欄位順序仍在。
 	s := string(out)
 	if !strings.Contains(s, "    - name: second\n") {
 		t.Fatalf("new item not appended in tea style:\n%s", s)
 	}
 }
 func TestUpsertLoginFirstEverLoginCreatesSection(t *testing.T) {
 	out, final, err := UpsertLogin(nil, LoginEntry{
 		Name: "only", URL: "https://gitea.alterminal.com", Token: "tok", User: "ceo",
 	}, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	logins := ListLogins(out)
 	if len(logins) != 1 || !logins[0].Default || logins[0].Token != "tok" {
 		t.Fatalf("first login should auto-default: %s", out)
 	}
 	if !final.Default {
 		t.Fatalf("final should be default: %+v", final)
 	}
 	if !strings.HasPrefix(string(out), "logins:\n") {
 		t.Fatalf("section not created:\n%s", out)
 	}
 }
 func TestUpsertLoginRejectsBadInput(t *testing.T) {
 	cases := []LoginEntry{
 		{Name: "", URL: "https://x", Token: "t"},
 		{Name: "n", URL: "  ", Token: "t"},
 		{Name: "n", URL: "https://x", Token: ""},
 	}
 	for _, e := range cases {
 		if _, _, err := UpsertLogin(nil, e, true); err == nil {
 			t.Errorf("UpsertLogin(%+v) should fail", e)
 		}
 	}
 }
 func TestSetDefaultLoginSwitchesFlag(t *testing.T) {
 	cfg := `logins:
    - name: a
      url: https://a.example.com
      token: ta
      default: true
    - name: b
      url: https://b.example.com
      token: tb
      default: false
 `
 	out, err := SetDefaultLogin([]byte(cfg), "b")
 	if err != nil {
 		t.Fatal(err)
 	}
 	logins := ListLogins(out)
 	if logins[0].Default || !logins[1].Default {
 		t.Fatalf("default flag not switched:\n%s", out)
 	}
 	// b 之後的內容（如有）不受影響。
 	if !strings.Contains(string(out), "token: ta") || !strings.Contains(string(out), "token: tb") {
 		t.Fatalf("tokens lost:\n%s", out)
 	}
 }
 func TestSetDefaultLoginUnknownNameErrors(t *testing.T) {
 	if _, err := SetDefaultLogin([]byte(realWorldTeaConfig), "nope"); err == nil {
 		t.Fatal("unknown name should error")
 	}
 }
 func TestRemoveLoginPromotesNextDefault(t *testing.T) {
 	// 第二個登入放在 logins 區段內（preferences 之前）。
 	cfg := `logins:
    - name: alterminal
      url: https://gitea.alterminal.com
      token: tok-1
      default: true
      user: ceo
    - name: backup
      url: https://backup.example.com
      token: tb
      default: false
 preferences:
    editor: false
 `
 	out, promoted, err := RemoveLogin([]byte(cfg), "alterminal")
 	if err != nil {
 		t.Fatal(err)
 	}
 	if promoted != "backup" {
 		t.Fatalf("promoted = %q, want backup:\n%s", promoted, out)
 	}
 	logins := ListLogins(out)
 	if len(logins) != 1 || logins[0].Name != "backup" || !logins[0].Default {
 		t.Fatalf("remaining login mismatch: %+v", logins)
 	}
 	if strings.Contains(string(out), "tok-1") || strings.Contains(string(out), "name: alterminal") {
 		t.Fatalf("login not fully removed:\n%s", out)
 	}
 }
 func TestRemoveLoginLastOne(t *testing.T) {
 	out, promoted, err := RemoveLogin([]byte(realWorldTeaConfig), "alterminal")
 	if err != nil || promoted != "" {
 		t.Fatalf("want clean removal, promoted=%q err=%v", promoted, err)
 	}
 	if strings.Contains(string(out), "alterminal") {
 		t.Fatalf("login not removed:\n%s", out)
 	}
 	if !strings.Contains(string(out), "preferences:") {
 		t.Fatalf("preferences section lost:\n%s", out)
 	}
 }
 func TestSaveTeaConfigFileAtomicAndMode(t *testing.T) {
 	dir := t.TempDir()
 	path := filepath.Join(dir, "tea", "config.yml")
 	if err := SaveTeaConfigFile(path, []byte("logins: []\n")); err != nil {
 		t.Fatal(err)
 	}
 	info, err := os.Stat(path)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if info.Mode().Perm() != 0o600 {
 		t.Fatalf("perm = %v, want 0600", info.Mode().Perm())
 	}
 	// 再寫一次（覆蓋既有檔），不留暫存殘檔。
 	if err := SaveTeaConfigFile(path, []byte("logins: []\n# v2\n")); err != nil {
 		t.Fatal(err)
 	}
 	entries, _ := os.ReadDir(filepath.Dir(path))
 	if len(entries) != 1 {
 		for _, e := range entries {
 			t.Logf("leftover: %s", e.Name())
 		}
 		t.Fatalf("want exactly 1 file, got %d", len(entries))
 	}
 	data, _ := os.ReadFile(path)
 	if !bytes.Contains(data, []byte("# v2")) {
 		t.Fatalf("overwrite failed: %s", data)
 	}
 }
 func TestSplitJoinLinesRoundTrip(t *testing.T) {
 	original := "a\nb\n"
 	got := string(joinLines(splitLines([]byte(original))))
 	if got != original {
 		t.Fatalf("round trip: %q", got)
 	}
 	if joinLines(splitLines(nil)) != nil {
 		t.Fatal("nil input should stay nil")
 	}
 }
 func TestYamlScalarQuoting(t *testing.T) {
 	cases := map[string]string{
 		"https://gitea.alterminal.com": "https://gitea.alterminal.com", // 含 : 與 / 的純量在 YAML 合法，不必引號
 		"tok-abc_123":                  "tok-abc_123",
 		"has space":                    `"has space"`,
 		"ceo":                          "ceo",
 	}
 	for in, want := range cases {
 		if got := yamlScalar(in); got != want {
 			t.Errorf("yamlScalar(%q) = %s, want %s", in, got, want)
 		}
 	}
 }
@@ -1,228 +0,0 @@
 // output.go — 共用輸出：JSON（預設）與 table（人工抽查）。
 //
 // 命令把結果包成 Values（欄位順序即輸出順序），再由 output 依格式輸出。
 // 這個設計讓同一份結果可以同時餵 JSON 與 table，不需要各自重組。
 package gitea
 import (
 	"encoding/json"
 	"fmt"
 	"io"
 	"strings"
 )
 // Values 是一組已排序的欄位值（依 Field 順序）。
 type Values []any
 // Format 是輸出格式。
 type Format int
 const (
 	// FormatJSON 輸出 JSON（預設）。
 	FormatJSON Format = iota
 	// FormatTable 輸出對齊的文字表格。
 	FormatTable
 )
 // ParseFormat 解析 --output 的值；不認得的值回傳錯誤。
 func ParseFormat(s string) (Format, error) {
 	switch strings.ToLower(strings.TrimSpace(s)) {
 	case "", "json":
 		return FormatJSON, nil
 	case "table":
 		return FormatTable, nil
 	default:
 		return FormatJSON, fmt.Errorf("invalid output format %q (want json or table)", s)
 	}
 }
 // Field 描述 table 輸出的一欄。
 type Field struct {
 	// Name 是欄位名（JSON 鍵與 table 表頭）。
 	Name string
 	// ValueFmt 是值的格式化函式；nil 時用預設（fmt.Sprint + JSON 引號字串）。
 	ValueFmt func(v any) string
 }
 // Printer 依格式輸出結果。
 type Printer struct {
 	// Format 是輸出格式。
 	Format Format
 	// Out 是輸出目標。
 	Out io.Writer
 }
 // PrintList 輸出清單。fields 定義欄位；rows 是每一列的欄位值。
 // JSON 模式輸出物件陣列；table 模式輸出對齊表格。
 func (p Printer) PrintList(fields []Field, rows []Values) error {
 	if p.Format == FormatTable {
 		return p.printTable(fields, rows)
 	}
 	w := p.Out
 	if len(rows) == 0 {
 		_, err := fmt.Fprintln(w, "[]")
 		return err
 	}
 	if _, err := fmt.Fprint(w, "["); err != nil {
 		return err
 	}
 	for i, row := range rows {
 		if i > 0 {
 			if _, err := fmt.Fprint(w, ","); err != nil {
 				return err
 			}
 		}
 		b, err := json.Marshal(mapOf(fields, row))
 		if err != nil {
 			return err
 		}
 		if _, err := w.Write(b); err != nil {
 			return err
 		}
 	}
 	_, err := fmt.Fprintln(w, "]")
 	return err
 }
 // PrintOne 輸出單一結果（物件）；v 已是可 JSON 化的值。
 // table 模式輸出 key: value 行。
 func (p Printer) PrintOne(fields []Field, row Values) error {
 	if p.Format == FormatTable {
 		return p.printTable(fields, []Values{row})
 	}
 	b, err := json.Marshal(mapOf(fields, row))
 	if err != nil {
 		return err
 	}
 	_, err = fmt.Fprintln(p.Out, string(b))
 	return err
 }
 // PrintNull 輸出「沒有結果」的 JSON null（table 模式輸出提示行）。
 func (p Printer) PrintNull() error {
 	if p.Format == FormatTable {
 		_, err := fmt.Fprintln(p.Out, "(none)")
 		return err
 	}
 	_, err := fmt.Fprintln(p.Out, "null")
 	return err
 }
 // printTable 印出對齊表格：表頭、分隔線、資料列。
 func (p Printer) printTable(fields []Field, rows []Values) error {
 	headers := make([]string, len(fields))
 	cells := make([][]string, len(rows))
 	for i, f := range fields {
 		headers[i] = f.Name
 	}
 	for r, row := range rows {
 		cells[r] = make([]string, len(fields))
 		for i := range fields {
 			cells[r][i] = formatValue(fields[i], row[i])
 		}
 	}
 	widths := make([]int, len(fields))
 	for i, h := range headers {
 		widths[i] = runeLen(h)
 	}
 	for _, row := range cells {
 		for i, c := range row {
 			if l := runeLen(c); l > widths[i] {
 				widths[i] = l
 			}
 		}
 	}
 	var b strings.Builder
 	for i, h := range headers {
 		fmt.Fprintf(&b, "%-*s", widths[i], h)
 		if i < len(headers)-1 {
 			b.WriteString("  ")
 		}
 	}
 	b.WriteString("\n")
 	for i := range fields {
 		fmt.Fprintf(&b, "%s", strings.Repeat("─", widths[i]))
 		if i < len(fields)-1 {
 			b.WriteString("  ")
 		}
 	}
 	b.WriteString("\n")
 	for _, row := range cells {
 		for i, c := range row {
 			fmt.Fprintf(&b, "%-*s", widths[i], c)
 			if i < len(fields)-1 {
 				b.WriteString("  ")
 				_ = i
 			}
 		}
 		b.WriteString("\n")
 	}
 	_, err := fmt.Fprint(p.Out, b.String())
 	return err
 }
 // mapOf 把欄位與值組成 JSON 物件用的 map（保留欄位順序由 encoding/json
 // 處理：map 會排序鍵，因此改用自組 slice 結構以保順序——見 marshalObject）。
 func mapOf(fields []Field, row Values) any {
 	if len(row) != len(fields) {
 		return nil
 	}
 	return orderedObject{fields, row}
 }
 // orderedObject 以欄位順序輸出 JSON 物件（避免 map 排序破壞欄位序）。
 type orderedObject struct {
 	fields []Field
 	row    Values
 }
 // MarshalJSON 按欄位順序輸出。
 func (o orderedObject) MarshalJSON() ([]byte, error) {
 	var b strings.Builder
 	b.WriteByte('{')
 	for i, f := range o.fields {
 		if i > 0 {
 			b.WriteByte(',')
 		}
 		k, err := json.Marshal(f.Name)
 		if err != nil {
 			return nil, err
 		}
 		b.Write(k)
 		b.WriteByte(':')
 		v, err := json.Marshal(o.row[i])
 		if err != nil {
 			return nil, err
 		}
 		b.Write(v)
 	}
 	b.WriteByte('}')
 	return []byte(b.String()), nil
 }
 // formatValue 把欄位值格式化為 table 用字串；nil → 空字串。
 func formatValue(f Field, v any) string {
 	if v == nil {
 		return ""
 	}
 	if f.ValueFmt != nil {
 		return f.ValueFmt(v)
 	}
 	switch x := v.(type) {
 	case string:
 		return x
 	case fmt.Stringer:
 		return x.String()
 	default:
 		return fmt.Sprint(x)
 	}
 }
 // runeLen 回傳字串的 rune 數（表格寬度用，CJK 後續可再調）。
 func runeLen(s string) int {
 	n := 0
 	for range s {
 		n++
 	}
 	return n
 }
@@ -1,88 +0,0 @@
 // output_test.go 驗證共用輸出：JSON 物件順序、空清單、table 對齊與
 // 格式解析。
 package gitea
 import (
 	"bytes"
 	"encoding/json"
 	"strings"
 	"testing"
 )
 var demoFields = []Field{
 	{Name: "type"},
 	{Name: "number"},
 }
 func TestPrintListJSON(t *testing.T) {
 	var b bytes.Buffer
 	p := Printer{Format: FormatJSON, Out: &b}
 	err := p.PrintList(demoFields, []Values{{"issue", 5}, {"pull", 7}})
 	if err != nil {
 		t.Fatal(err)
 	}
 	var got []map[string]any
 	if err := json.Unmarshal(b.Bytes(), &got); err != nil {
 		t.Fatalf("invalid JSON %q: %v", b.String(), err)
 	}
 	if len(got) != 2 || got[0]["type"] != "issue" || got[1]["number"] != float64(7) {
 		t.Fatalf("unexpected payload: %v", got)
 	}
 }
 func TestPrintListEmptyJSONArray(t *testing.T) {
 	var b bytes.Buffer
 	p := Printer{Format: FormatJSON, Out: &b}
 	if err := p.PrintList(demoFields, nil); err != nil {
 		t.Fatal(err)
 	}
 	if strings.TrimSpace(b.String()) != "[]" {
 		t.Fatalf("want [], got %q", b.String())
 	}
 }
 func TestPrintNull(t *testing.T) {
 	var b bytes.Buffer
 	p := Printer{Format: FormatJSON, Out: &b}
 	if err := p.PrintNull(); err != nil {
 		t.Fatal(err)
 	}
 	if strings.TrimSpace(b.String()) != "null" {
 		t.Fatalf("want null, got %q", b.String())
 	}
 }
 func TestPrintTable(t *testing.T) {
 	var b bytes.Buffer
 	p := Printer{Format: FormatTable, Out: &b}
 	if err := p.PrintList(demoFields, []Values{{"issue", 5}}); err != nil {
 		t.Fatal(err)
 	}
 	out := b.String()
 	for _, want := range []string{"type", "number", "issue", "5"} {
 		if !strings.Contains(out, want) {
 			t.Fatalf("table missing %q:\n%s", want, out)
 		}
 	}
 	if !strings.Contains(out, "─") {
 		t.Fatalf("table should have separator:\n%s", out)
 	}
 }
 func TestParseFormat(t *testing.T) {
 	for in, want := range map[string]Format{
 		"":        FormatJSON,
 		"json":    FormatJSON,
 		"JSON":    FormatJSON,
 		"table":   FormatTable,
 		" Table ": FormatTable,
 	} {
 		got, err := ParseFormat(in)
 		if err != nil || got != want {
 			t.Errorf("ParseFormat(%q) = %v, %v; want %v", in, got, err, want)
 		}
 	}
 	if _, err := ParseFormat("yaml"); err == nil {
 		t.Error("yaml should be rejected")
 	}
 }