.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "JSC 程式碼審查 plugin（Claude Code / Codex / Antigravity / OpenCode），提供 RPG 攻防式 git diff review、裁決結果歸檔、Gitea AI review findings 修復/PR 流程，以及 C# / .NET NuGet 套件更新流程；於 Claude Code 以 /jsc: 前綴呼叫。",
   "skills": "./skills",
   "author": {

.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "JSC 程式碼審查 plugin，提供 RPG 攻防式 git diff review、裁決結果歸檔、Gitea AI review findings 修復/PR 流程，以及 C# / .NET NuGet 套件更新流程。",
   "skills": "./skills"
 }

README.md

@@ -42,7 +42,10 @@ code-review/
 │   ├── code-review-archive/ # 保存裁決：成立→已知問題、誤判→排除事項
 │   ├── code-review-resolve/ # 解決 findings.json + 分類提交 + push + 發 PR
 │   ├── code-review-nuget/   # C# / .NET NuGet 套件更新 + build 驗證
-│   └── code-review-sync/    # 依擁有者批次 clone／更新 Gitea 專案
+│   ├── code-review-sync/    # 依擁有者批次 clone／更新 Gitea 專案
+│   ├── code-review-action-docker/    # action 容器化（Node 主程式）+ 串接 doc-funcs
+│   ├── code-review-action-composite/ # composite action 標準化 + 串接 doc-funcs
+│   └── code-review-image/            # Dockerfile 整理成六步流程 + 串接 doc-funcs
 ├── AGENTS.md                # 跨助理共用指引
 └── README.md
 ```
@@ -218,6 +221,36 @@ rm -rf ~/.config/opencode/skills/code-review
 - **Codex**：`$code-review-sync`，或 `$code-review-sync --owner plugins --target-dir ~/work`，或用 `/skills` 選單
 - **OpenCode**：描述需求（如「用 GITEA_TOKEN 取得我有讀取權限的所有 Gitea 專案，依擁有者分組讓我多選，把選定擁有者的專案 clone 到家目錄；已存在的切到 develop／master 更新到最新」）自動觸發
 
+### `code-review-action-docker`
+
+把 Gitea／GitHub「Docker 容器 action」專案標準化為 **Node 主程式＋容器化**，再串接文件化流程。五階段：(A) 找出 action 專案、讀 `action.yml`／`action.yaml` 的 `name`／`description`、判斷主程式語言；(B) 主程式**非 Node 則保守改寫為 Node**（高風險，先以 AskUserQuestion 確認，保留對外行為），並把所有 `.js` 集中到 **`app/`**、同步更新 `require`／`import` 路徑、`package.json` 與 `action.yml`；(C) 產生 `entrypoint.sh`，**啟動 node 前先輸出 action 名稱／用途／更新時間**（Asia/Taipei `yyyy/MM/dd HH:mm:ss`）再 `exec node`；(D) 依**六步流程**（參數處理 → 安裝套件 → 複製檔案 → 執行程序 → 縮小映像檔 → 設定入口）產生**使用最新 node 版本**的 `Dockerfile`，**每步內容依主程式（`app/`）實作量身決定**（先盤點相依／是否需 build／OS 層相依／入口檔再填對應步驟，用不到的不硬塞），預設 build 基底 `node:latest`、runtime `node:slim`、**多階段建置縮小映像**，`ENTRYPOINT` 指向 `entrypoint.sh`；(E) 對整個專案**完整執行 `/jsc:doc-funcs`**（function 文件、`entrypoint.sh`／`Dockerfile` 逐行註解、重建 README）。
+
+參數：`[--action-dir <action 根目錄>] [--node-version <node tag>] [--main <主程式檔>] [--yes]`（根目錄預設目前工作目錄；node 版本預設最新；主程式自動判斷；`--yes` 略過一般確認，但主程式改寫與 doc-funcs 的實作詢問仍會中斷）。
+
+- **Claude Code / Antigravity**：`/jsc:code-review-action-docker`，或 `/jsc:code-review-action-docker --action-dir ~/work/my-action --node-version 22`
+- **Codex**：`$code-review-action-docker`，或 `$code-review-action-docker --action-dir ~/work/my-action`，或用 `/skills` 選單
+- **OpenCode**：描述需求（如「把這個 action 主程式改成 node、所有 js 收進 app/，產生會先輸出 action 名稱／用途／更新時間再啟動 node 的 entrypoint.sh、用最新 node 版本的 Dockerfile，最後跑 doc-funcs 補文件並重建 README」）自動觸發
+
+### `code-review-action-composite`
+
+把 Gitea／GitHub「composite action」專案標準化，再串接文件化流程。四階段：(A) 找出 action 專案、讀 `action.yml`／`action.yaml` 的 `name`／`description`／`runs`、判斷是否為 composite；(B) **已是 composite 則保留既有 `steps`**，非 composite（JS／Docker）則**保守確認後對齊**為 composite（高風險先以 AskUserQuestion 確認，保留 `inputs`／`outputs` 契約；Docker 行為無法等價塞入時標「需人工確認」並建議改用 `code-review-action-docker`）；(C) 在 `runs.steps` **最前面注入啟動橫幅 step**，輸出 action **名稱／用途／更新時間**（Asia/Taipei `yyyy/MM/dd HH:mm:ss`，固定字串），並於 `action.yml` 開頭補用途／更新時間註解區塊（既有橫幅 step 則更新而非重插）；(D) 對整個專案**完整執行 `/jsc:doc-funcs`**（`action.yml` 與被引用腳本逐行註解、function 文件、重建 README）。
+
+參數：`[--action-dir <action 根目錄>] [--manifest <action.yml 路徑>] [--yes]`（根目錄預設目前工作目錄；manifest 自動尋找 `action.yml`／`action.yaml`；`--yes` 略過一般確認，但「非 composite 需對齊」與 doc-funcs 的實作詢問仍會中斷）。
+
+- **Claude Code / Antigravity**：`/jsc:code-review-action-composite`，或 `/jsc:code-review-action-composite --action-dir ~/work/my-action`
+- **Codex**：`$code-review-action-composite`，或 `$code-review-action-composite --action-dir ~/work/my-action`，或用 `/skills` 選單
+- **OpenCode**：描述需求（如「把這個 composite action 標準化，在 steps 最前面加一個會輸出 action 名稱／用途／更新時間的 step，最後跑 doc-funcs 補文件並重建 README」）自動觸發
+
+### `code-review-image`
+
+把專案既有的 `Dockerfile` **整理成固定六步流程**，再串接文件化流程。三階段：(A) 找出專案根目錄、定位目標 `Dockerfile`（找不到則詢問、**不臆造**；要產生全新 action 容器請改用 `code-review-action-docker`），讀現有指令、判斷語言／生態與既有 base image／建置流程；(B) 在**保留建置行為**前提下，把指令重整／歸位為**六步流程**（參數處理 → 安裝套件 → 複製檔案 → 執行程序 → 縮小映像檔 → 設定入口）：可調參數集中於檔首 `ARG`、相依描述先 `COPY` 以利 layer 快取、**多階段建置**讓 runtime 改用較小基底（`*-slim`／`*-alpine`／`distroless` 等）只帶執行所需產物；`ENTRYPOINT`／`CMD`／`EXPOSE`／`ENV` 等對外契約不動，**無法保證等價的重整先以 AskUserQuestion 確認**（可選最小重排或只補註解）；(C) 對整個專案**完整執行 `/jsc:doc-funcs`**（`Dockerfile` 等指令檔逐行註解、function 文件、重建 README）。
+
+參數：`[--project-dir <專案根目錄>] [--dockerfile <Dockerfile 路徑>] [--yes]`（專案根目錄預設目前工作目錄；Dockerfile 自動定位、多個時詢問；`--yes` 略過一般確認，但「重整無法保證行為等價」與 doc-funcs 的實作詢問仍會中斷）。
+
+- **Claude Code / Antigravity**：`/jsc:code-review-image`，或 `/jsc:code-review-image --project-dir ~/work/my-app --dockerfile build/Dockerfile`
+- **Codex**：`$code-review-image`，或 `$code-review-image --dockerfile docker/Dockerfile`，或用 `/skills` 選單
+- **OpenCode**：描述需求（如「把這個專案的 Dockerfile 整理成參數處理→安裝套件→複製檔案→執行程序→縮小映像檔→設定入口六步、用多階段建置縮小映像，最後跑 doc-funcs 補文件並重建 README」）自動觸發
+
 <!-- JSC-SKILLS:END -->
 
 ---

plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "JSC 程式碼審查 plugin，提供 RPG 攻防式 git diff review、裁決結果歸檔、Gitea AI review findings 修復/PR 流程，以及 C# / .NET NuGet 套件更新流程；於 Antigravity 以 /jsc: 前綴呼叫。",
   "skills": "./skills/"
 }

skills/code-review-action-composite/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: code-review-action-composite
+description: 將 Gitea／GitHub「composite action」專案標準化並串接文件化流程：(1) 確認 action 為 composite（`runs.using: composite`），非 composite 則保守確認後對齊；(2) 在 `runs.steps` 最前面注入啟動橫幅 step，輸出 action 名稱／用途／更新時間（Asia/Taipei `yyyy/MM/dd HH:mm:ss`），並於 `action.yml` 開頭補用途／更新時間註解區塊；(3) 最後完整執行 `/jsc:doc-funcs` 處理流程（function 文件、指令檔逐行註解、重建 README）。當使用者說整理 composite action、把 action 標準化為 composite、讓 composite action 啟動時印名稱／用途／更新時間、對 composite action 補文件，或提到 code-review-action-composite 時觸發。不適用於：Docker 容器 action（用 code-review-action-docker）、非 action 專案、或不需文件化的一般 repo。
+argument-hint: "[--action-dir <action 根目錄>] [--manifest <action.yml 路徑>] [--yes]"
+---
+
+# code-review-action-composite — composite action 標準化＋文件化
+
+四階段 skill：先做**前置設定與偵測**（找出 action 專案、讀取名稱／用途、判斷是否為 composite），再**確認／對齊為 composite action**，接著在 `runs.steps` 最前面**注入會輸出 action 名稱／用途／更新時間的啟動橫幅 step**，最後**完整執行 `/jsc:doc-funcs` 處理流程**替整個專案補文件並重建 README。
+
+| 階段 | 動作 |
+| --- | --- |
+| A. 前置設定與偵測 | 決定 action 根目錄 → 讀 `action.yml`／`action.yaml` 的 `name`／`description`／`runs` → 判斷是否為 composite |
+| B. 對齊為 composite | 已是 composite 則保留既有 `steps`；非 composite 則**保守確認後對齊**（高風險，先確認），整理被引用的腳本路徑 |
+| C. 注入啟動橫幅 step | 在 `runs.steps` 最前面插入一個 shell step，輸出 action **名稱／用途／更新時間**；並於 `action.yml` 開頭補用途／更新時間註解區塊 |
+| D. 串接 doc-funcs | 對整個 action 專案完整執行 `/jsc:doc-funcs` 流程（function 文件、指令檔逐行註解、重建 README） |
+
+---
+
+## 輸出規範（務必遵守）
+
+- **語言**：所有面向使用者的輸出（計畫、進度、總結、反問）一律使用**繁體中文（台灣用語）**；僅識別字、檔名、git 指令、API 路徑、YAML 鍵名、程式碼等技術標識保留原文，**不可**使用簡體字。
+- **編碼無亂碼**：凡輸出含繁體中文、全形標點、emoji，一律 **UTF-8（不含 BOM）**，不得出現問號方框或錯碼。產生／覆寫的 `action.yml`／`action.yaml`、被引用腳本、`README.md` 同樣需 UTF-8（不含 BOM）。
+- **自動執行原則**：除非使用者明確要求先確認，或遇到不可忽略的必要決策，否則各階段只需輸出簡短計畫／進度後直接執行到完成。**一定會中斷詢問的點**：階段 B 主 action「非 composite 需對齊」時（破壞性，須先確認），以及階段 D 由 `/jsc:doc-funcs` 自身的「如何實作」詢問。
+- **不破壞既有工作**：改寫 `action.yml`／搬移或改寫被引用腳本前，若工作區有未提交變更，先提醒使用者建議先 commit／備份；**絕不** `reset --hard`／`checkout -f`／`clean`，也不刪除使用者既有原始碼。移動檔案優先用 `git mv` 以保留歷史。
+- **保留行為**：對齊 composite 與注入橫幅 step 只「補強」既有流程，不得擅自改變既有 `steps` 的執行順序、輸入（`inputs`）／輸出（`outputs`）契約或副作用；任何無法可靠等價推論的改動一律不做，並以註解或回報標註「需人工確認」。
+- **不擴及無關檔案**：本 skill 只動 action 專案根目錄內的：`action.yml`／`action.yaml`、其 `steps` 直接引用的內嵌腳本（如 `*.sh`／`*.ps1`），以及階段 D 由 doc-funcs 流程處理的目標；排除 `node_modules`／`.git`／`.docs`／`bin`／`obj`／第三方依賴。
+
+---
+
+## 參數
+
+格式：`[--action-dir <action 根目錄>] [--manifest <action.yml 路徑>] [--yes]`
+
+- `--action-dir <action 根目錄>`：action 專案根目錄。**省略時預設目前工作目錄**（須含 `action.yml`／`action.yaml`，否則依 A1 詢問）。
+- `--manifest <action.yml 路徑>`：指定 action manifest 檔（相對 action 根目錄）。省略時依 A1 自動尋找 `action.yml`／`action.yaml`。
+- `--yes`：盡量不中斷。即使帶此參數，「非 composite 需對齊」與 doc-funcs 的「如何實作」仍會詢問。
+
+---
+
+## 階段 A：前置設定與偵測
+
+### A1. 決定 action 根目錄與 manifest
+
+- 帶 `--action-dir` → 採用（展開 `~`）；省略 → 用目前工作目錄。
+- manifest：帶 `--manifest` → 採用；否則於根目錄找 `action.yml`，再退而 `action.yaml`。
+- **找不到** action manifest → 回報「此目錄不是 action 專案（缺 action.yml／action.yaml）」並詢問正確路徑，**不臆測**、不在非 action 專案上動工。
+
+### A2. 讀取 action 名稱與用途
+
+從 action manifest 讀取：
+
+- `name`：action 名稱（供啟動橫幅與 README 使用）。
+- `description`：action 用途。
+- `runs`：目前的執行設定（`using`、`steps`、`main`、`image`、`entrypoint` 等）。
+- `inputs`／`outputs`：對外契約（後續不得破壞）。
+
+若 `name`／`description` 缺漏，回報並請使用者補；無法取得時於後續輸出以「（未提供）」保守標示，**不編造**。
+
+### A3. 判斷是否為 composite
+
+依 `runs.using` 判定：
+
+- `composite` → 即為目標型態，記下既有 `runs.steps`，直接進入階段 B 的「已是 composite」分支。
+- `node*`（JS action）／`docker`（Docker 容器 action）／其他 → 視為**非 composite**。
+
+輸出偵測結果（action 名稱、用途、`runs.using`、是否為 composite、既有 step 數量），再進入階段 B。
+
+> 若偵測為 **Docker 容器 action**，且使用者本意是容器化而非 composite，提醒可改用 `/jsc:code-review-action-docker`，再依使用者裁示決定是否續行。
+
+---
+
+## 階段 B：確認／對齊為 composite action
+
+### B1. 已是 composite
+
+- 確認 `runs.using: composite` 與既有 `runs.steps`，**不更動既有 steps 的順序與邏輯**，直接進入階段 C。
+- 順手檢查 step 的必要欄位（`run` step 須有 `shell`；`uses` step 的引用是否存在），有疑慮以回報標註，不擅改。
+
+### B2. 非 composite（需對齊）
+
+這是**破壞性高風險決策**：先以 `AskUserQuestion` 向使用者確認，選項至少含「對齊為 composite」「維持原樣只做文件化（略過對齊）」「改用 code-review-action-docker」「其他」。經確認「對齊為 composite」後才改寫：
+
+- 將 `runs` 保守對齊為 composite，把原執行入口轉為 composite step：
+  - 原 JS action（`runs.using: node*`，`runs.main: <x>.js`）→ 轉為一個 `run` step，於 step 內以 `node <x>.js` 執行（`shell: bash`），保留 `inputs`／`outputs` 與環境變數（`INPUT_*`）契約。
+  - 原 Docker action（`runs.using: docker`）→ Docker 行為通常無法可靠等價地塞進 composite；**不臆測改寫**，以回報＋`# 需人工確認` 標註，並建議改用 `/jsc:code-review-action-docker`。
+- 任何無法可靠等價對齊處，**不臆測**：以 `# 需人工確認：...` 標註並回報，保留原檔行為。
+
+對齊後的 `runs` 形如：
+
+```yaml
+runs:
+  using: composite
+  steps:
+    # （階段 C 會在此處最前面插入啟動橫幅 step）
+    - name: <原執行入口轉成的 step>
+      shell: bash
+      run: node ./index.js
+```
+
+---
+
+## 階段 C：注入啟動橫幅 step（輸出名稱／用途／更新時間）
+
+在 `runs.steps` **最前面**插入（或更新）一個輸出橫幅的 step，讓 composite action 一啟動就**輸出 action 名稱、用途、更新時間**；並於 `action.yml` 開頭補用途／更新時間註解區塊。
+
+- **更新時間**為產生此檔當下的時間戳，使用台灣時區（Asia/Taipei）並固定為 `yyyy/MM/dd HH:mm:ss`（可用 `TZ='Asia/Taipei' date +'%Y/%m/%d %H:%M:%S'` 取得），**寫成檔內固定字串**（非執行期動態時間）。
+- 名稱／用途取自階段 A2 的 `action.yml`（缺漏時以「（未提供）」標示）。
+- 橫幅 step 須有可辨識的 `name`（如 `顯示 action 資訊`）與 `shell: bash`；其後緊接既有／對齊後的 steps，**不更動既有 steps**。
+- 若已存在本 skill 先前插入的橫幅 step（依 `name` 辨識），則**更新**其內容與更新時間，不重複插入。
+
+範例（既有 steps 接在橫幅 step 之後）：
+
+```yaml
+name: <action name>
+description: <action description>
+
+runs:
+  using: composite
+  steps:
+    # 啟動橫幅：輸出名稱／用途／更新時間（此 step 由 code-review-action-composite 產生）
+    - name: 顯示 action 資訊
+      shell: bash
+      run: |
+        echo "================================================"
+        echo "Action  : <action name>"
+        echo "用途    : <action description>"
+        echo "更新時間: 2026/06/30 18:30:05"
+        echo "================================================"
+    # === 以下為既有／對齊後的 steps（保持原順序與邏輯）===
+    - name: <既有 step>
+      shell: bash
+      run: node ./index.js
+```
+
+- `action.yml` 開頭的「用途／更新時間」註解區塊與每行註解，最終會在階段 D 由 `/jsc:doc-funcs` 的指令檔流程統一補齊／覆寫為標準格式（用途與更新日期同一註解區塊、逐行註解）；本階段先確保**執行期橫幅輸出**正確即可。
+- 自我檢查：插入橫幅 step 後 YAML 仍可解析（縮排、`steps` 為 list、每個 `run` step 都有 `shell`），且 `inputs`／`outputs` 未被更動。
+
+---
+
+## 階段 D：完整執行 /jsc:doc-funcs 處理流程
+
+標準化完成後，對**整個 action 專案**完整執行 `/jsc:doc-funcs` 流程，替程式碼與指令檔補文件並重建 README：
+
+- 以階段 A1 的 action 根目錄為目標，執行 `doc-funcs` skill 的完整流程（判斷語言 → 掃描 function 與指令檔 → 建立 `.docs/` 草稿 → 草稿品質檢查 → 詢問使用者如何實作 → 依選擇寫回 → 保守優化 → 重建 README → 錨點檢查 → 清理草稿 → 建置／語法驗證）。
+- doc-funcs 會把 `action.yml`／`action.yaml` 視為 CI／部署設定檔處理：補齊「用途＋更新日期同一註解區塊」與逐行註解；`steps` 內引用的腳本（`*.sh`／`*.ps1` 等）逐行註解；專案內各 function 補文件註解。
+- doc-funcs 的「如何實作」詢問（全部一起／逐個／其他）由使用者於該流程內裁示，本 skill 不代為決定。
+- 完成後依 doc-funcs 規範重建根目錄 `README.md`（含台灣時區更新時間、專案列表、功能列表、使用範例）。
+
+> 銜接方式：在本 skill 環境中以 `/jsc:doc-funcs`（或 Skill 工具）啟動 doc-funcs 流程；若該流程需參數，沿用本 skill 的 action 根目錄為目標專案。
+
+---
+
+## 總結
+
+各階段執行後輸出：
+
+- **階段 A**：action 根目錄、manifest 路徑、action 名稱／用途、`runs.using`、是否為 composite、既有 step 數量。
+- **階段 B**：是否對齊為 composite（及對齊摘要與「需人工確認」清單），或維持原樣的理由。
+- **階段 C**：橫幅 step 的輸出內容（名稱／用途／更新時間）與插入位置，並確認既有 steps、`inputs`／`outputs` 未被破壞。
+- **階段 D**：doc-funcs 流程的處理結果（文件化的 function 與指令檔、重建的 README）。
+- 列出本次新增／變更的檔案與其相對路徑，並提醒使用者於提交前確認 `action.yml` 可正常解析、composite action 能正確啟動並輸出橫幅。
+
+---
+
+## 呼叫方式
+
+格式：`[--action-dir <action 根目錄>] [--manifest <action.yml 路徑>] [--yes]` — 全部可省略（根目錄預設目前工作目錄；manifest 自動尋找）。
+
+| 助理 | 呼叫 |
+| --- | --- |
+| Claude Code / Antigravity | `/jsc:code-review-action-composite`，或 `/jsc:code-review-action-composite --action-dir ~/work/my-action` |
+| Codex | `$code-review-action-composite`，或 `$code-review-action-composite --action-dir ~/work/my-action`，或用 `/skills` 選單 |
+| OpenCode | 描述需求（如「把這個 composite action 標準化，在 steps 最前面加一個會輸出 action 名稱／用途／更新時間的 step，最後跑 doc-funcs 補文件並重建 README」）自動觸發 |

skills/code-review-action-docker/SKILL.md

@@ -0,0 +1,241 @@
+---
+name: code-review-action-docker
+description: 將 Gitea／GitHub「Docker 容器 action」專案標準化為 Node 主程式＋容器化，並串接文件化流程：(1) 檢查 action 主程式是否為 Node，否則保守改寫為 Node，且所有 `.js` 檔一律集中到 `app/` 資料夾；(2) 產生 `entrypoint.sh`，啟動前先輸出 action 名稱／用途／更新時間，再執行 node 主程式；(3) 產生使用最新 node 版本的 `Dockerfile`；(4) 最後完整執行 `/jsc:doc-funcs` 處理流程（function 文件、指令檔逐行註解、重建 README）。當使用者說把 action 改成 docker／node、容器化 action、action 主程式 node 化、把 js 收進 app、產 entrypoint.sh／Dockerfile 給 action，或提到 code-review-action-docker 時觸發。不適用於：非 action 專案、純前端打包、或不需容器化的一般 repo。
+argument-hint: "[--action-dir <action 根目錄>] [--node-version <node tag>] [--main <主程式檔>] [--yes]"
+---
+
+# code-review-action-docker — action 容器化（Node 主程式）＋文件化
+
+五階段 skill：先做**前置設定與偵測**（找出 action 專案、讀取名稱／用途、判斷主程式語言），再把**主程式 Node 化並將所有 `.js` 收進 `app/`**，接著產生**啟動前先輸出 action 名稱／用途／更新時間的 `entrypoint.sh`**，然後產生**使用最新 node 版本的 `Dockerfile`**（並對齊 `action.yml` 的 docker 設定），最後**完整執行 `/jsc:doc-funcs` 處理流程**替整個專案補文件並重建 README。
+
+| 階段 | 動作 |
+| --- | --- |
+| A. 前置設定與偵測 | 決定 action 根目錄 → 讀 `action.yml`／`action.yaml` 的 `name`／`description` → 判斷目前主程式與語言 |
+| B. 主程式 Node 化 | 主程式非 Node 則**保守改寫**為 Node（高風險，先確認）→ 所有 `.js` 集中到 `app/`，更新所有引用、`package.json`、`action.yml` |
+| C. entrypoint.sh | 產生 `entrypoint.sh`：先輸出 action **名稱／用途／更新時間**，再 `exec` node 主程式 |
+| D. Dockerfile | 依六步流程（參數處理 → 安裝套件 → 複製檔案 → 執行程序 → 縮小映像檔 → 設定入口）產生使用**最新 node 版本**的 `Dockerfile`，多階段建置縮小映像、`ENTRYPOINT` 指向 `entrypoint.sh` |
+| E. 串接 doc-funcs | 對整個 action 專案完整執行 `/jsc:doc-funcs` 流程（function 文件、指令檔逐行註解、重建 README） |
+
+---
+
+## 輸出規範（務必遵守）
+
+- **語言**：所有面向使用者的輸出（計畫、進度、總結、反問）一律使用**繁體中文（台灣用語）**；僅識別字、檔名、git／docker 指令、API 路徑、程式碼等技術標識保留原文，**不可**使用簡體字。
+- **編碼無亂碼**：凡輸出含繁體中文、全形標點、emoji，一律 **UTF-8（不含 BOM）**，不得出現問號方框或錯碼。產生／覆寫的 `entrypoint.sh`、`Dockerfile`、`action.yml`、`README.md` 同樣需 UTF-8（不含 BOM）。
+- **自動執行原則**：除非使用者明確要求先確認，或遇到不可忽略的必要決策，否則各階段只需輸出簡短計畫／進度後直接執行到完成。**一定會中斷詢問的點**：階段 B 主程式「非 Node 需改寫」時（破壞性，須先確認），以及階段 E 由 `/jsc:doc-funcs` 自身的「如何實作」詢問。
+- **不破壞既有工作**：移動 `.js`、改寫主程式、覆寫 `entrypoint.sh`／`Dockerfile`／`action.yml` 前，若工作區有未提交變更，先提醒使用者建議先 commit／備份；**絕不** `reset --hard`／`checkout -f`／`clean`，也不刪除使用者既有原始碼。移動檔案優先用 `git mv` 以保留歷史。
+- **保留行為**：Node 化只「翻譯」既有邏輯，不得擅自改變對外行為、輸入輸出契約或副作用；任何無法可靠等價推論的改動一律不做，並以註解或回報標註「需人工確認」。
+- **不擴及無關檔案**：本 skill 只動 action 專案根目錄內的：主程式、`.js`（搬移到 `app/`）、`package.json`、`action.yml`／`action.yaml`、`entrypoint.sh`、`Dockerfile`，以及階段 E 由 doc-funcs 流程處理的目標；排除 `node_modules`／`.git`／`.docs`／`bin`／`obj`／第三方依賴。
+
+---
+
+## 參數
+
+格式：`[--action-dir <action 根目錄>] [--node-version <node tag>] [--main <主程式檔>] [--yes]`
+
+- `--action-dir <action 根目錄>`：action 專案根目錄。**省略時預設目前工作目錄**（須含 `action.yml`／`action.yaml`，否則依 A1 詢問）。
+- `--node-version <node tag>`：`Dockerfile` 的 node base image tag（如 `22`、`22-alpine`、`lts`）。**省略時預設使用最新 node 版本**（`node:latest`，見階段 D）。
+- `--main <主程式檔>`：指定主程式入口檔（相對 action 根目錄）。省略時依 A3 自動判斷。
+- `--yes`：盡量不中斷。即使帶此參數，「主程式非 Node 需改寫」與 doc-funcs 的「如何實作」仍會詢問。
+
+---
+
+## 階段 A：前置設定與偵測
+
+### A1. 決定 action 根目錄
+
+- 帶 `--action-dir` → 採用（展開 `~`）。
+- 省略 → 用目前工作目錄。
+- 根目錄須存在 `action.yml` 或 `action.yaml`（action manifest）。**找不到** action manifest → 回報「此目錄不是 action 專案（缺 action.yml／action.yaml）」並詢問正確路徑，**不臆測**、不在非 action 專案上動工。
+
+### A2. 讀取 action 名稱與用途
+
+從 action manifest 讀取：
+
+- `name`：action 名稱（供 `entrypoint.sh` 輸出與 README 使用）。
+- `description`：action 用途。
+- `runs`：目前的執行設定（`using`、`main`、`image`、`entrypoint` 等）。
+
+若 `name`／`description` 缺漏，回報並請使用者補；無法取得時於後續輸出以「（未提供）」保守標示，**不編造**。
+
+### A3. 判斷目前主程式與語言
+
+依序判斷主程式入口（取第一個成立者）：
+
+1. 帶 `--main <主程式檔>` → 直接採用。
+2. `action.yml` 為 JS action（`runs.using: node*`）→ 取 `runs.main`。
+3. `action.yml` 為 docker action（`runs.using: docker`）→ 看 `runs.entrypoint`／`Dockerfile` 的 `ENTRYPOINT`／`CMD` 推主程式。
+4. 以上皆無 → 依專案檔與副檔名分布推斷（`package.json` 的 `main`／`bin`、`index.js`、`*.sh`、`*.py` 等）。
+
+判定**主程式是否為 Node**：入口為 `.js`／`.mjs`／`.cjs` 且由 `node` 執行即視為 Node；入口為 shell／python／其他則視為非 Node。輸出偵測結果（action 名稱、用途、主程式檔、判定語言、是否為 Node），再進入階段 B。
+
+---
+
+## 階段 B：主程式 Node 化，並將所有 `.js` 收進 `app/`
+
+### B1. 主程式 Node 化
+
+- **已是 Node** → 確認入口檔，不改寫邏輯，直接進 B2。
+- **非 Node（shell／python／其他）** → 這是**破壞性高風險決策**：先以 `AskUserQuestion` 向使用者確認是否改寫為 Node，選項至少含「改寫為 Node」「維持原樣只做容器化（略過改寫）」「其他」。經確認後才改寫：
+  - 逐段把原主程式邏輯**保守翻譯**為 Node（建議 `index.js`）；保留對外行為、輸入（環境變數／`INPUT_*`／args）與輸出（stdout／exit code／檔案副作用）契約。
+  - 外部指令呼叫以 `child_process`（`execFileSync`／`spawnSync`）對應；檔案操作以 `fs`；環境變數以 `process.env`。
+  - 任何無法可靠等價翻譯處，**不臆測**：以 `// 需人工確認：...` 標註並回報。
+  - 改寫完成後，原非 Node 主程式於 B2 一併處理（移除或保留由使用者裁示；預設保留並在 README／回報標註已由 Node 取代）。
+
+### B2. 所有 `.js` 集中到 `app/`
+
+- 在 action 根目錄建立 `app/`（若不存在）。
+- 將專案內所有 `.js`／`.mjs`／`.cjs`（排除 `node_modules`／`.git`／`.docs`／`bin`／`obj`／第三方依賴）**移入 `app/`**，優先 `git mv` 保留歷史。主程式入口統一為 `app/index.js`（或 `app/<main>.js`）。
+- **移動後必須更新所有引用**，確保不破壞：
+  - 模組間的 `require`／`import` 相對路徑。
+  - `package.json` 的 `main`／`bin`／`scripts`／`exports`（指向 `app/...`）。
+  - `action.yml`／`Dockerfile`／`entrypoint.sh` 內對主程式路徑的引用。
+- 若 `app/` 下無 `package.json` 而專案需要相依，於 `app/` 建立或移入 `package.json`，`main` 指向入口檔；不擅自新增與功能無關的相依。
+
+### B3. action.yml 對齊 docker
+
+將 manifest 的 `runs` 對齊為 docker 容器 action（保留既有 `inputs`／`outputs`／`name`／`description`）：
+
+```yaml
+runs:
+  using: docker
+  image: Dockerfile
+  entrypoint: entrypoint.sh
+```
+
+若原本是 JS action（`using: node*`），改為上述 docker 設定；若已是 docker action，確認 `image` 指向 `Dockerfile`、`entrypoint` 指向 `entrypoint.sh`。
+
+---
+
+## 階段 C：產生 entrypoint.sh（先輸出名稱／用途／更新時間，再啟動 node 主程式）
+
+在 action 根目錄產生（或覆寫）`entrypoint.sh`：**啟動 node 主程式前，先輸出 action 名稱、用途、更新時間**。
+
+- **更新時間**為產生此檔當下的時間戳，使用台灣時區（Asia/Taipei）並固定為 `yyyy/MM/dd HH:mm:ss`（可用 `TZ='Asia/Taipei' date +'%Y/%m/%d %H:%M:%S'` 取得），**寫成檔內固定字串**（非執行期動態時間）。
+- 名稱／用途取自階段 A2 的 `action.yml`。
+- 最後以 `exec node <主程式>`（如 `exec node /action/app/index.js "$@"`）啟動，讓 node 取代 shell 行程，正確傳遞訊號與 exit code；路徑須與階段 D 的 `Dockerfile` 落點一致。
+
+範例（實際路徑依階段 B 入口而定）：
+
+```sh
+#!/bin/sh
+set -e
+
+# action 啟動橫幅：輸出名稱／用途／更新時間（此檔由 code-review-action-docker 產生）
+echo "================================================"
+echo "Action  : <action name>"
+echo "用途    : <action description>"
+echo "更新時間: 2026/06/30 18:30:05"
+echo "================================================"
+
+# 啟動 node 主程式（以 exec 取代 shell，正確處理訊號與 exit code）
+exec node /action/app/index.js "$@"
+```
+
+- 賦予可執行權限：`chmod +x entrypoint.sh`（並於 git 標記為可執行）。
+- 此檔開頭的「用途／更新時間」與每行註解，最終會在階段 E 由 `/jsc:doc-funcs` 的指令檔流程統一補齊／覆寫為標準格式（用途與更新日期同一註解區塊、逐行註解）；本階段先確保**執行期輸出**正確即可。
+
+---
+
+## 階段 D：產生 Dockerfile（使用最新 node 版本，六步流程依主程式實作量身產生）
+
+在 action 根目錄產生（或覆寫）`Dockerfile`，**base image 使用最新 node 版本**，採**多階段建置**以縮小最終映像檔。六步流程是**骨架**，但**每一步的實際內容必須依階段 B 的主程式（`app/`）實作決定**——不要套用與主程式無關的固定樣板，也不要硬塞主程式用不到的安裝或建置指令。
+
+### D0. 先盤點主程式實作需求
+
+產生 Dockerfile 前，先檢視 `app/` 主程式與 `package.json`，判斷各步該放什麼：
+
+- **相依套件**：`app/package.json` 的 `dependencies`／`devDependencies`、是否有 lockfile（`package-lock.json`／`npm-shrinkwrap.json`）。決定第 2 步用 `npm ci` 還是 `npm install`、是否需要 dev 相依來 build。
+- **是否需要 build／transpile**：有無 `scripts.build`、是否為 TypeScript／打包（產物落在 `dist/`／`build/` 等）。決定第 4 步是否要跑建置、第 5 步 runtime 該帶入哪個產物目錄。
+- **OS 層相依**：主程式是否以 `child_process` 呼叫外部執行檔（如 `git`、`bash`、`openssl`、`python3`、`ffmpeg`、`imagemagick`），或使用需編譯的原生模組（node-gyp／native addon）。決定第 2 步是否要 `apt-get install` 對應套件，以及第 5 步 runtime 基底是否需保留這些執行檔。
+- **執行期需求**：主程式讀取的環境變數、需存取的檔案路徑、是否寫入暫存目錄。決定 `WORKDIR`、需 `COPY` 的檔案範圍與必要的 `ENV`。
+- **入口檔**：階段 B 決定的主程式入口（如 `app/index.js`），決定第 6 步與 `entrypoint.sh` 內 `node` 路徑。
+
+### D1～D6：依盤點結果填入六步
+
+1. **參數處理**：以 `ARG` 注入 node 版本（預設最新）與主程式需要的 build-time 參數；可調參數集中在檔案開頭。
+2. **安裝套件**：依 D0 的相依結果安裝——有 lockfile 用 `npm ci`、否則 `npm install`；不需 build 時加 `--omit=dev`，需 build 時先裝完整相依（含 dev）供第 4 步使用。**只在主程式真的會用到時**才 `apt-get install` OS 套件，並於同一 `RUN` 清掉 apt 快取。先 `COPY` 相依描述（`package*.json`）再安裝，以利 layer 快取。
+3. **複製檔案**：`COPY` 主程式實際需要的檔案（`app/`、`entrypoint.sh`，及主程式會讀取的資源）；不需要的檔案不必帶入。
+4. **執行程序**：賦予 `entrypoint.sh` 執行權限；**僅當 D0 判定需要 build／transpile 時**才執行（如 `npm run build`），否則此步只做權限設定，不要硬加建置指令。
+5. **縮小映像檔**：多階段建置，runtime 改用 slim 基底，只 `COPY --from=build` 帶入主程式執行**真正需要**的產物——有 build 產物時帶入 `dist/` 與 production `node_modules`（`npm prune --omit=dev` 或重裝 production 相依），純 JS 無 build 時帶入 `app/` 與 production `node_modules`；若 D0 判定 runtime 需要某些 OS 執行檔，於 runtime 階段一併安裝（slim 基底可能不含）。不要把 build 階段的 dev 相依與快取帶進最終映像。
+6. **設定入口**：`ENTRYPOINT` 指向 `entrypoint.sh`，其內 `node` 路徑為 D0 的入口檔。
+
+base image 版本：預設 build 基底 `node:latest`、runtime 基底 `node:slim`（皆為最新版，slim 用於縮小）；帶 `--node-version <tag>`（如 `22`、`lts`）時改用 `node:<tag>` 與 `node:<tag>-slim`。若需確認當前最新穩定版號，可查詢 Docker Hub（`https://hub.docker.com/_/node`）後於 `FROM` 註記實際版本，但**預設行為是使用最新版**。
+
+下列為**最簡基準骨架**（純 JS、無 build、無 OS 相依的情況）；實際內容須依 D0 盤點調整，第 4 步建置、第 2／5 步 OS 套件等視主程式需要增刪：
+
+```Dockerfile
+# syntax=docker/dockerfile:1
+
+# 1. 參數處理：node 版本以 ARG 注入（預設最新版；--node-version 可覆寫）
+ARG NODE_VERSION=latest
+ARG NODE_RUNTIME=slim
+
+# ---- build 階段：安裝相依、準備產物 ----
+FROM node:${NODE_VERSION} AS build
+WORKDIR /action
+
+# 2. 安裝套件：先帶相依描述以利 layer 快取，再裝 app/ 相依
+#    （需 build 時改裝完整相依；需 OS 套件時於此 apt-get install 並清快取）
+COPY app/package*.json /action/app/
+RUN if [ -f /action/app/package.json ]; then \
+        cd /action/app && (npm ci --omit=dev || npm install --omit=dev); \
+    fi
+
+# 3. 複製檔案：複製主程式實際需要的檔案
+COPY . /action
+
+# 4. 執行程序：賦予 entrypoint 執行權限（D0 判定需要 build 時於此 npm run build）
+RUN chmod +x /action/entrypoint.sh
+
+# 5. 縮小映像檔：多階段建置，runtime 改用 slim 基底、只帶必要產物
+#    （有 build 產物時改帶 dist/ 與 production node_modules；runtime 需要的 OS 執行檔於此安裝）
+FROM node:${NODE_RUNTIME} AS runtime
+WORKDIR /action
+COPY --from=build /action /action
+
+# 6. 設定入口：以 entrypoint.sh 啟動（其內 node 指向 D0 的入口檔）
+ENTRYPOINT ["/action/entrypoint.sh"]
+```
+
+- **依主程式實作**：上面只是基準骨架。若主程式是 TypeScript／需打包，第 4 步要加 `npm run build`、第 5 步只帶 `dist/` 與 production 相依；若主程式會 spawn 外部執行檔或用原生模組，第 2／5 步要補對應 OS 套件；用不到的步驟內容不要硬塞。
+- **版號對齊**：runtime 的 slim 基底版號需與 build 基底一致。預設 `node:latest` ↔ `node:slim`；帶 `--node-version 22` 時設 `NODE_VERSION=22`、`NODE_RUNTIME=22-slim`。注意**沒有 `node:latest-slim` 這個 tag**，最新版 slim 一律用 `node:slim`，故以獨立的 `NODE_RUNTIME` 參數帶入、不要用 `${NODE_VERSION}-slim` 組裝。
+- **自我檢查**：`entrypoint.sh` 的 `node <主程式>` 路徑（如 `/action/app/index.js`）需與 `Dockerfile` 的 `WORKDIR`／`COPY` 落點一致，避免容器啟動時找不到主程式。
+- 此檔的用途／更新日期註解與逐行註解，同樣於階段 E 由 doc-funcs 指令檔流程統一補齊。
+
+---
+
+## 階段 E：完整執行 /jsc:doc-funcs 處理流程
+
+容器化與 Node 化完成後，對**整個 action 專案**完整執行 `/jsc:doc-funcs` 流程，替程式碼與指令檔補文件並重建 README：
+
+- 以階段 A1 的 action 根目錄為目標，執行 `doc-funcs` skill 的完整流程（判斷語言 → 掃描 function 與指令檔 → 建立 `.docs/` 草稿 → 草稿品質檢查 → 詢問使用者如何實作 → 依選擇寫回 → 保守優化 → 重建 README → 錨點檢查 → 清理草稿 → 建置／語法驗證）。
+- doc-funcs 會涵蓋本次新增／變更的指令檔：`entrypoint.sh`（補齊「用途＋更新日期同一註解區塊」與逐行註解）、`Dockerfile`（逐行註解）；以及 `app/` 內 Node 主程式與各 function 的文件註解。
+- doc-funcs 的「如何實作」詢問（全部一起／逐個／其他）由使用者於該流程內裁示，本 skill 不代為決定。
+- 完成後依 doc-funcs 規範重建根目錄 `README.md`（含台灣時區更新時間、專案列表、功能列表、使用範例）。
+
+> 銜接方式：在本 skill 環境中以 `/jsc:doc-funcs`（或 Skill 工具）啟動 doc-funcs 流程；若該流程需參數，沿用本 skill 的 action 根目錄為目標專案。
+
+---
+
+## 總結
+
+各階段執行後輸出：
+
+- **階段 A**：action 根目錄、action 名稱／用途、原主程式檔與語言、是否為 Node。
+- **階段 B**：是否改寫主程式（及改寫摘要與「需人工確認」清單）、搬入 `app/` 的 `.js` 清單、已更新的引用（`package.json`／`action.yml`／路徑）。
+- **階段 C／D**：`entrypoint.sh` 的輸出內容（名稱／用途／更新時間）與啟動的 node 主程式、`Dockerfile` 採用的 node 版本與 `ENTRYPOINT`。
+- **階段 E**：doc-funcs 流程的處理結果（文件化的 function 與指令檔、重建的 README）。
+- 列出本次新增／變更的檔案與其相對路徑，並提醒使用者於提交前確認 `entrypoint.sh` 有可執行權限、容器能正確啟動。
+
+---
+
+## 呼叫方式
+
+格式：`[--action-dir <action 根目錄>] [--node-version <node tag>] [--main <主程式檔>] [--yes]` — 全部可省略（根目錄預設目前工作目錄；node 版本預設最新；主程式自動判斷）。
+
+| 助理 | 呼叫 |
+| --- | --- |
+| Claude Code / Antigravity | `/jsc:code-review-action-docker`，或 `/jsc:code-review-action-docker --action-dir ~/work/my-action --node-version 22` |
+| Codex | `$code-review-action-docker`，或 `$code-review-action-docker --action-dir ~/work/my-action`，或用 `/skills` 選單 |
+| OpenCode | 描述需求（如「把這個 action 主程式改成 node、所有 js 收進 app/，產生會先輸出 action 名稱／用途／更新時間再啟動 node 的 entrypoint.sh、用最新 node 版本的 Dockerfile，最後跑 doc-funcs 補文件並重建 README」）自動觸發 |

skills/code-review-image/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: code-review-image
+description: 把專案的 `Dockerfile` 整理成固定六步流程並串接文件化流程：(1) 找出專案根目錄與目標 `Dockerfile`、判斷語言／生態與既有建置方式；(2) 在保留建置行為的前提下，把 `Dockerfile` 重整為 **參數處理 → 安裝套件 → 複製檔案 → 執行程序 → 縮小映像檔 → 設定入口** 六步流程（以多階段建置縮小最終映像，可調參數集中於檔首 `ARG`，相依描述先 `COPY` 以利 layer 快取）；(3) 最後完整執行 `/jsc:doc-funcs` 處理流程（function 文件、`Dockerfile` 等指令檔逐行註解、重建 README）。當使用者說整理／重構 Dockerfile、把 Dockerfile 排成參數處理→安裝→複製→執行→縮小→入口六步、優化映像檔分層／多階段建置、縮小 image，或提到 code-review-image 時觸發。不適用於：Gitea／GitHub action 容器化（用 code-review-action-docker）、composite action（用 code-review-action-composite）、或專案內沒有也不需要 Dockerfile 的情況。
+argument-hint: "[--project-dir <專案根目錄>] [--dockerfile <Dockerfile 路徑>] [--yes]"
+---
+
+# code-review-image — Dockerfile 六步流程整理＋文件化
+
+三階段 skill：先做**前置設定與偵測**（找出專案根目錄、定位目標 `Dockerfile`、判斷語言／生態與既有建置方式），再把 `Dockerfile` **重整為固定六步流程**（參數處理 → 安裝套件 → 複製檔案 → 執行程序 → 縮小映像檔 → 設定入口，並以多階段建置縮小最終映像），最後**完整執行 `/jsc:doc-funcs` 處理流程**替整個專案補文件並重建 README。
+
+| 階段 | 動作 |
+| --- | --- |
+| A. 前置設定與偵測 | 決定專案根目錄 → 定位目標 `Dockerfile`（找不到則詢問，不臆造）→ 讀現有指令、判斷語言／生態、既有 base image 與建置流程 |
+| B. 整理 Dockerfile 為六步流程 | 在**保留建置行為**前提下，把指令重整／歸位為六步：參數處理 → 安裝套件 → 複製檔案 → 執行程序 → 縮小映像檔 → 設定入口；多階段建置縮小映像；行為不等價處標「需人工確認」並先確認 |
+| C. 串接 doc-funcs | 對整個專案完整執行 `/jsc:doc-funcs` 流程（function 文件、`Dockerfile` 等指令檔逐行註解、重建 README） |
+
+---
+
+## 輸出規範（務必遵守）
+
+- **語言**：所有面向使用者的輸出（計畫、進度、總結、反問）一律使用**繁體中文（台灣用語）**；僅識別字、檔名、git／docker 指令、API 路徑、程式碼等技術標識保留原文，**不可**使用簡體字。
+- **編碼無亂碼**：凡輸出含繁體中文、全形標點、emoji，一律 **UTF-8（不含 BOM）**，不得出現問號方框或錯碼。產生／覆寫的 `Dockerfile`、`README.md` 同樣需 UTF-8（不含 BOM）。
+- **自動執行原則**：除非使用者明確要求先確認，或遇到不可忽略的必要決策，否則各階段只需輸出簡短計畫／進度後直接執行到完成。**一定會中斷詢問的點**：階段 B「重整無法可靠保證建置行為等價」時（破壞性，須先確認），以及階段 C 由 `/jsc:doc-funcs` 自身的「如何實作」詢問。
+- **不破壞既有工作**：覆寫 `Dockerfile` 前，若工作區有未提交變更，先提醒使用者建議先 commit／備份；**絕不** `reset --hard`／`checkout -f`／`clean`，也不刪除使用者既有原始碼。
+- **保留建置行為**：重整只「重新組織與分層」既有指令，不得擅自改變最終映像的內容、檔案落點、相依版本、暴露的 port、`ENV`、`ENTRYPOINT`／`CMD` 對外契約或建置副作用；任何無法可靠等價推論的調整一律不做，並以註解或回報標註「需人工確認」。多階段建置縮小映像時，runtime 階段必須帶齊執行所需的所有產物（執行檔、相依、靜態資源、`ENV`、暴露 port），不得遺漏導致容器無法啟動。
+- **不擴及無關檔案**：本 skill 階段 A／B 只動目標 `Dockerfile`（及與其直接相關、為保留行為而必須同步的 `.dockerignore`）；其餘檔案僅在階段 C 由 doc-funcs 流程依其規範處理。排除 `node_modules`／`.git`／`.docs`／`bin`／`obj`／第三方依賴。
+
+---
+
+## 參數
+
+格式：`[--project-dir <專案根目錄>] [--dockerfile <Dockerfile 路徑>] [--yes]`
+
+- `--project-dir <專案根目錄>`：專案根目錄。**省略時預設目前工作目錄**。
+- `--dockerfile <Dockerfile 路徑>`：指定要整理的 `Dockerfile`（相對專案根目錄）。省略時依 A2 自動定位；找到多個時詢問。
+- `--yes`：盡量不中斷。即使帶此參數，「重整無法保證建置行為等價」與 doc-funcs 的「如何實作」仍會詢問。
+
+---
+
+## 階段 A：前置設定與偵測
+
+### A1. 決定專案根目錄
+
+- 帶 `--project-dir` → 採用（展開 `~`）。
+- 省略 → 用目前工作目錄。
+
+### A2. 定位目標 Dockerfile
+
+- 帶 `--dockerfile` → 採用（相對專案根目錄；展開後須存在）。
+- 省略 → 於專案根目錄與常見位置尋找 `Dockerfile`（含 `Dockerfile.*`、`*/Dockerfile`，排除 `node_modules`／`.git`／`.docs`／`bin`／`obj`／第三方依賴）。
+  - 恰好一個 → 直接採用。
+  - 多個 → 以 `AskUserQuestion` 列出讓使用者選擇要整理哪一個（或逐一整理）。
+  - **找不到** → 回報「專案內找不到 `Dockerfile`」並詢問正確路徑；**不臆造** Dockerfile、不在沒有 Dockerfile 的專案上憑空生成（本 skill 的職責是「整理既有 Dockerfile」，產生全新 action 容器請改用 `/jsc:code-review-action-docker`）。
+
+### A3. 讀現有指令並判斷語言／生態與既有建置流程
+
+讀取目標 `Dockerfile` 全文，盤點並記錄（作為階段 B 重整與 C doc-funcs 的依據）：
+
+- **base image 與階段**：所有 `FROM`（含多階段 `AS <name>`）、目前是單階段或多階段。
+- **可調參數**：既有 `ARG`／`ENV`（版本、路徑、build flag 等）。
+- **安裝步驟**：OS 套件（`apt`／`apk`／`yum` 等）、語言相依（`npm ci`／`pip install`／`go mod download`／`dotnet restore`／`mvn`／`gradle` 等）、相依描述檔（`package*.json`／`requirements.txt`／`go.mod`／`*.csproj`／`pom.xml` 等）。
+- **複製與建置**：`COPY`／`ADD` 來源與落點、`RUN` 建置／編譯／transpile（`npm run build`／`go build`／`dotnet publish`／`mvn package` 等）、`WORKDIR`、`USER`、檔案權限（`chmod`）。
+- **執行設定**：`EXPOSE`、`ENV`、`VOLUME`、`HEALTHCHECK`、`ENTRYPOINT`／`CMD`（這些是對外契約，重整時不得改變語意）。
+- **語言／生態**：依 base image 與安裝指令、專案檔分布推斷主要語言（供階段 C doc-funcs 第 0 步沿用，也決定縮小映像時的 runtime 基底選擇）。
+
+輸出偵測結果（目標 Dockerfile 路徑、單／多階段、base image、推斷語言、既有 `ENTRYPOINT`／`CMD`／`EXPOSE`／`ENV`），再進入階段 B。
+
+---
+
+## 階段 B：整理 Dockerfile 為六步流程
+
+在**保留建置行為**的前提下，把目標 `Dockerfile` 的指令重整／歸位為**固定六步流程**，並採**多階段建置**縮小最終映像。各步驟對應如下：
+
+1. **參數處理**：把可調參數集中到檔案開頭，以 `ARG` 注入（base image 版本、build flag、路徑等）；`# syntax` 指示與全域 `ARG` 置於最前。
+2. **安裝套件**：先 `COPY` 相依描述檔（如 `package*.json`／`requirements.txt`／`go.mod go.sum`／`*.csproj`）再安裝，以利 layer 快取；OS 套件與語言相依在此安裝，安裝後清理快取（如 `apt-get clean`／`rm -rf /var/lib/apt/lists/*`、`--no-cache`）以縮小該層。
+3. **複製檔案**：`COPY` 其餘原始碼到映像（搭配 `.dockerignore` 排除無關檔案）。
+4. **執行程序**：build／compile／transpile（如 `npm run build`／`go build`／`dotnet publish`）與必要的權限設定（`chmod`）於此執行。
+5. **縮小映像檔**：多階段建置，runtime 階段改用較小的基底（如 `*-slim`／`*-alpine`／`distroless`／`scratch`，依語言與既有 base 對應），只 `COPY --from=<build>` 帶入**執行所必需**的產物（執行檔／發佈輸出／必要相依／靜態資源），避免把 build 階段的快取、原始碼與 dev 工具帶進最終映像；同步搬移 runtime 階段需要的 `ENV`／`WORKDIR`／`EXPOSE`／`USER`。
+6. **設定入口**：`ENTRYPOINT`／`CMD` 置於最後，語意與原檔一致。
+
+**重整原則（關鍵）**
+
+- **語意等價優先**：重排指令前，先確認該調整不改變最終映像內容與建置結果。某些重排會改變行為（例如 `ARG` 的作用範圍跨 `FROM` 會失效、`COPY` 順序影響快取與覆蓋、`RUN` 之間有狀態相依、單階段改多階段時 runtime 缺少 build 期才有的檔案）。**凡無法可靠保證等價的重整，先以 `AskUserQuestion` 向使用者確認**（選項至少含「依建議重整（多階段＋六步）」「只在不改變行為前提下做最小重排」「維持原結構只補註解（略過重整，交給階段 C）」「其他」），確認後才覆寫。
+- **已是多階段** → 將既有各階段對應到六步（build 階段涵蓋 1–4、runtime 階段涵蓋 5–6），補齊缺漏的快取最佳化與清理，不破壞既有 `--from` 依賴。
+- **單階段改多階段** → 僅在能可靠判斷 runtime 真正需要哪些產物時才做；無法可靠判斷時，**不臆測**，標 `# 需人工確認：runtime 需要的產物清單` 並回報，退回「最小重排＋補註解」。
+- **多階段不適用** → 若該映像本質上無法受益於多階段（例如純資料映像、最終就是要完整建置環境），保留單階段，於步驟 5 以註解說明「此映像不適用多階段縮小」，其餘步驟仍依序歸位。
+- **對外契約不動**：`ENTRYPOINT`／`CMD`／`EXPOSE`／`ENV`／`VOLUME`／`HEALTHCHECK`／`USER` 的語意保持與原檔一致；只可調整位置與分層，不可改變值或刪除。
+- **`.dockerignore`**：若為了「複製檔案」步驟的正確性需要排除建置產物／`node_modules`／`.git`，可建立或補強 `.dockerignore`（僅新增排除項，不刪既有），並回報。
+
+重整骨架（實際指令、base image、語言依階段 A 偵測結果填入；非 Node 專案請換成對應語言的安裝／建置指令與 runtime 基底）：
+
+```Dockerfile
+# syntax=docker/dockerfile:1
+
+# 1. 參數處理：可調參數集中於檔首，以 ARG 注入
+ARG BUILD_IMAGE=<build-base>
+ARG RUNTIME_IMAGE=<runtime-base-slim>
+
+# ---- build 階段：安裝相依、複製原始碼、建置產物 ----
+FROM ${BUILD_IMAGE} AS build
+WORKDIR /app
+
+# 2. 安裝套件：先帶相依描述以利 layer 快取，再安裝（並清理快取縮小該層）
+COPY <dependency-manifests> ./
+RUN <install-deps>
+
+# 3. 複製檔案：複製其餘原始碼（搭配 .dockerignore）
+COPY . .
+
+# 4. 執行程序：build / compile / transpile、必要權限設定
+RUN <build-command>
+
+# ---- 5. 縮小映像檔：runtime 改用較小基底，只帶執行所需產物 ----
+FROM ${RUNTIME_IMAGE} AS runtime
+WORKDIR /app
+COPY --from=build /app/<artifacts> ./<artifacts>
+# （搬移 runtime 需要的 ENV / EXPOSE / USER，語意與原檔一致）
+
+# 6. 設定入口：ENTRYPOINT / CMD 置於最後，語意同原檔
+ENTRYPOINT [<entrypoint>]
+```
+
+- **自我檢查**：重整後確認 (1) `ARG` 在使用它的 `FROM` 之後有重新宣告（跨階段 `ARG` 規則）；(2) runtime 階段 `COPY --from` 帶齊執行所需全部產物；(3) `ENTRYPOINT`／`CMD`／`EXPOSE`／`ENV` 與原檔語意一致；(4) 路徑（`WORKDIR`／`COPY` 落點）一致、容器能找到入口。
+- 此檔的「用途／更新日期」開頭註解區塊與逐行註解，於階段 C 由 `/jsc:doc-funcs` 的指令檔流程統一補齊／覆寫為標準格式；本階段先確保**建置行為**正確、六步結構清楚即可。
+- **建置驗證**：若環境可執行 `docker build`，重整後做一次建置驗證（或至少 `docker build --check`／語法檢查）確認可建置；無法執行時明確說明原因並標註風險（階段 C doc-funcs 第 11 步亦會做語法驗證）。
+
+---
+
+## 階段 C：完整執行 /jsc:doc-funcs 處理流程
+
+Dockerfile 六步整理完成後，對**整個專案**完整執行 `/jsc:doc-funcs` 流程，替程式碼與指令檔補文件並重建 README：
+
+- 以階段 A1 的專案根目錄為目標，執行 `doc-funcs` skill 的完整流程（判斷語言 → 掃描 function 與指令檔 → 建立 `.docs/` 草稿 → 草稿品質檢查 → 詢問使用者如何實作 → 依選擇寫回 → 保守優化 → 重建 README → 錨點檢查 → 清理草稿 → 建置／語法驗證）。
+- doc-funcs 會把本次整理的 `Dockerfile` 視為部署設定檔處理：補齊「用途＋更新日期同一註解區塊」與逐行註解（每行有效指令上方或行尾說明其作用、為何需要、重要參數或副作用）；專案內各 function 補文件註解；其他指令檔（腳本／CI／`docker-compose*` 等）一併處理。
+- doc-funcs 的「如何實作」詢問（全部一起／逐個／其他）由使用者於該流程內裁示，本 skill 不代為決定。
+- 完成後依 doc-funcs 規範重建根目錄 `README.md`（含台灣時區更新時間、專案列表、功能列表、使用範例）。
+
+> 銜接方式：在本 skill 環境中以 `/jsc:doc-funcs`（或 Skill 工具）啟動 doc-funcs 流程；若該流程需參數，沿用本 skill 的專案根目錄為目標專案。
+
+---
+
+## 總結
+
+各階段執行後輸出：
+
+- **階段 A**：專案根目錄、目標 `Dockerfile` 路徑、單／多階段、base image、推斷語言、既有 `ENTRYPOINT`／`CMD`／`EXPOSE`／`ENV`。
+- **階段 B**：重整摘要（六步歸位結果、是否改為多階段、縮小映像採用的 runtime 基底）、「需人工確認」清單、是否做過建置／語法驗證；並確認對外契約（`ENTRYPOINT`／`CMD`／`EXPOSE`／`ENV` 等）未被破壞。
+- **階段 C**：doc-funcs 流程的處理結果（文件化的 function 與指令檔、重建的 README）。
+- 列出本次新增／變更的檔案與其相對路徑，並提醒使用者於提交前確認 `Dockerfile` 可正確建置、容器能正常啟動。
+
+---
+
+## 呼叫方式
+
+格式：`[--project-dir <專案根目錄>] [--dockerfile <Dockerfile 路徑>] [--yes]` — 全部可省略（專案根目錄預設目前工作目錄；Dockerfile 自動定位，多個時詢問）。
+
+| 助理 | 呼叫 |
+| --- | --- |
+| Claude Code / Antigravity | `/jsc:code-review-image`，或 `/jsc:code-review-image --project-dir ~/work/my-app --dockerfile build/Dockerfile` |
+| Codex | `$code-review-image`，或 `$code-review-image --dockerfile docker/Dockerfile`，或用 `/skills` 選單 |
+| OpenCode | 描述需求（如「把這個專案的 Dockerfile 整理成參數處理→安裝套件→複製檔案→執行程序→縮小映像檔→設定入口六步、用多階段建置縮小映像，最後跑 doc-funcs 補文件並重建 README」）自動觸發 |