@moon791017/neo-skills 1.0.20 → 1.0.22

package/GEMINI.md

@@ -1,6 +1,6 @@
 # Neo Skills Extension
 
-**Neo Skills** is a Gemini CLI extension that transforms the agent into a **Universal Expert Agent**. It utilizes the Model Context Protocol (MCP) to provide domain-specific expertise ("Skills") and automated execution protocols ("Commands"). While currently equipped with specialized **DevOps** modules (Azure Pipelines, Git), its architecture is designed to host skills from any domain.
+**Neo Skills** is a Gemini CLI extension that transforms the agent into a **Universal Expert Agent**. It utilizes the Model Context Protocol (MCP) to provide domain-specific expertise ("Skills"). While currently equipped with specialized **DevOps** modules (Azure Pipelines, Git), its architecture is designed to host skills from any domain.
 
 ## Constraints
 - All MCP commands must be manually executed by the user and cannot be automated!
@@ -13,7 +13,7 @@ You must engage in "fact-check thinking" before answering. Unless explicitly pro
 
 This project serves as a "Cortex" for the Gemini agent, enabling it to:
 1.  **Understand** complex contexts across various domains via structured knowledge bases (`SKILL.md`).
-2.  **Execute** precise workflows using pre-validated templates (`templates/`) and command definitions (`.toml`).
+2.  **Execute** precise workflows using pre-validated templates (`templates/`) and skill definitions (`SKILL.md`).
 3.  **Standardize** outputs to ensure consistency and reliability.
 
 ## 📂 System Architecture
@@ -23,7 +23,6 @@ The project is organized into three main layers:
 ### 1. The MCP Server (`src/server.ts`)
 The entry point of the extension. It runs an MCP server that:
 *   Registers **Tools** (e.g., `fetch_web_content` for web scraping).
-*   Registers **Prompts** (e.g., `neo:git_commit`) which are dynamic templates that inject context and instructions into the chat session.
 
 ### 2. The Knowledge Base (`skills/`)
 Each subdirectory represents a "Skill Module" containing expert knowledge.
@@ -32,12 +31,7 @@ Each subdirectory represents a "Skill Module" containing expert knowledge.
     *   `templates/`: The "Hands". A library of reusable assets that the agent should use instead of writing code from scratch.
 *   **Example:** `skills/neo-azure-pipelines/` contains logic for designing CI/CD pipelines and templates for .NET builds, IIS deployments, etc.
 
-### 3. The Action Registry (`commands/`)
-Defines rigid, executable workflows triggered by the user.
-*   **Format:** TOML files (e.g., `ci-dotnet.toml`, `git-commit.toml`).
-*   **Purpose:** These files contain the "System Prompt" or "Instructions" that are fed to the agent when a specific task is requested. They explicitly link a user request to a specific Skill.
-
-### 4. Security Layer (`src/hooks/`)
+### 3. Security Layer (`src/hooks/`)
 Mechanisms to ensure operational safety and data privacy.
 *   **Secret Guard (`secret-guard.ts`)**: An interception hook that analyzes tool execution arguments in real-time. It blocks operations involving sensitive files (e.g., `.env`, private keys, credentials) to prevent accidental leakage.
 
@@ -88,23 +82,23 @@ When interacting with this codebase or using the extension, the agent follows th
 
 *   **Web Scraper:** 從指定的 URL 獲取網頁 HTML 內容，支援 CSS 選擇器 (`fetch_web_content`)。
 
-*   **Git Automation:** Automatically generate Conventional Commit messages in English and ask for confirmation before committing (`neo:git_commit`).
+*   **Git Automation:** 根據暫存區變更自動生成 Conventional Commits 訊息，經使用者確認後執行 commit。
 
-*   **CI Protocols:** 自動配置 .NET 專案的 Azure Pipelines CI 建置流程 (`neo:ci-dotnet`)。
+*   **CI Protocols:** 自動配置 .NET 專案的 Azure Pipelines CI 建置流程。
 
-*   **CD Protocols:** 為專案自動配置 Azure App Service (`neo:cd-app-service`) 與地端 IIS (`neo:cd-iis`) 的部署流程 (CD)。
+*   **CD Protocols:** 為專案自動配置 Azure App Service 與地端 IIS 的部署流程 (CD)。
 
-*   **Requirement Clarification:** 系統化引導用戶釐清模糊需求，並將其轉化為結構化的規格文件 (`neo:clarification`)。
+*   **Requirement Clarification:** 系統化引導用戶釐清模糊需求，並將其轉化為結構化的規格文件。
 
-*   **Code Explanation:** 分析原始碼或專案結構，提供技術解析與架構洞察 (`neo:explain`)。
+*   **Code Explanation:** 分析原始碼或專案結構，提供技術解析與架構洞察。
 
-*   **Code Review:** 對當前變更或指定檔案進行全方位的程式碼審查 (`neo:code-review`)。
+*   **Code Review:** 對當前變更或指定檔案進行全方位的程式碼審查。
 
 *   **C# 現代語法專家:** 跨版本 C# 專家 (10-14+)，專注於現代化語法、強型別與高效能開發模式。
 
 *   **.NET 開發專家群:** 包含核心環境路由，以及針對 Minimal APIs、Web API、MVC 與 EF Core 的深度技術指引與開發規範。
 
-*   **C# Interface Generation:** 針對指定的 C# 類別生成對應的 Interface，並提供智慧覆蓋功能 (`neo:dotnet-gen-interface`)。
+*   **C# Interface Generation:** 針對指定的 C# 類別生成對應的 Interface，並提供智慧覆蓋功能。
 
 *   **Python 3.10+ 現代開發專家:** 專注於 Python 3.10 至 3.14 的現代語法特性、型別安全與非同步開發。
 

package/README.md

@@ -11,26 +11,26 @@
 本專案作為 AI Agent 的「大腦皮層 (Cortex)」，旨在打造一個**全能型 Agent 框架**，透過以下機制提升 AI 的專業度：
 
 1.  **領域專精 (Skills)**：可擴充的專家知識庫 (`SKILL.md`)。目前已內建 DevOps 模組，未來將持續擴增更多領域。
-2.  **標準化執行 (Commands)**：提供預先驗證的自動化腳本與模板，確保產出的一致性與可靠性。
+2.  **標準化範本 (Templates)**：提供預先驗證的自動化腳本與模板，確保產出的一致性與可靠性。
 3.  **架構思維**：強制執行「感知 (Perceive) -> 推理 (Reason) -> 行動 (Act)」的決策迴圈，避免 AI 產生幻覺，確保解決方案的精準度。
 
 ## ✨ 目前內建技能 (Built-in Skills)
 
 ### 1. Azure Pipelines 架構師
 自動化設計與生成符合微軟最佳實踐的 CI/CD 流程。
-*   **CI 自動化 (`neo:ci-dotnet`)**：針對 .NET 專案生成建置管線，整合單元測試與構件發佈。
+*   **CI 自動化**：針對 .NET 專案生成建置管線，整合單元測試與構件發佈。
 *   **CD 自動化**：
-    *   **Azure App Service (`neo:cd-app-service`)**：部署至Azure App Service。
-    *   **IIS On-Premises (`neo:cd-iis`)**：部署至地端 IIS 伺服器，包含備份與復原機制。
+    *   **Azure App Service**：部署至Azure App Service。
+    *   **IIS On-Premises**：部署至地端 IIS 伺服器，包含備份與復原機制。
 
 ### 2. 智慧 Git 助手
-*   **Smart Commit (`neo:git_commit`)**：根據 `git diff` 暫存區內容，自動生成符合 Conventional Commits 規範的提交訊息。
+*   **Smart Commit**：根據 `git diff` 暫存區內容，自動生成符合 Conventional Commits 規範的提交訊息。
 
 ### 3. Code Review 專家
-*   **智能審查 (`neo:code-review`)**：針對程式碼變更進行多面向 (正確性、安全性、效能、可讀性) 的深度審查。
+*   **智能審查**：針對程式碼變更進行多面向 (正確性、安全性、效能、可讀性) 的深度審查。
 
 ### 4. 程式碼解釋助手
-*   **技術解析 (`neo:explain`)**：深入分析原始碼或專案結構，提供高階用途摘要、邏輯流程分解以及核心元件說明。
+*   **技術解析**：深入分析原始碼或專案結構，提供高階用途摘要、邏輯流程分解以及核心元件說明。
 
 ### 5. .NET / C# 開發專家
 *   **C# 現代語法專家 (`skills/neo-csharp`)**：跨版本 C# 專家 (10-14+)，專注於現代化語法、強型別與高效能開發模式。
@@ -39,7 +39,7 @@
 *   **.NET Web API 專家 (`skills/neo-dotnet-webapi`)**：提供控制器模式下的架構設計、Problem Details 與異常處理指引。
 *   **.NET MVC 專家 (`skills/neo-dotnet-mvc`)**：處理伺服器端渲染 (SSR)、視圖模型與標籤協助程式的最佳實踐。
 *   **EF Core 專家 (`skills/neo-dotnet-ef-core`)**：專注於資料庫建模、移轉管理與 Linq 查詢優化。
-*   **Interface 生成器 (`neo:dotnet-gen-interface`)**：針對 C# Class 自動生成符合規範的 Interface，並支援智慧檔案覆蓋功能。
+*   **Interface 生成器**：針對 C# Class 自動生成符合規範的 Interface，並支援智慧檔案覆蓋功能。
 
 ### 6. Python 開發與環境管理專家
 *   **Python 3.10+ 專家 (`skills/neo-python`)**：專注於 Python 3.10 至 3.14 的現代語法特性、型別安全與非同步開發。
@@ -50,7 +50,7 @@
 *   **SwiftUI 專家 (`skills/neo-swift-ui`)**：支援 iOS 16.0+ 與 Swift 5.0+ 的現代開發模式，專注於 NavigationStack、Observation 框架、資料流架構及高效能視圖設計。
 
 ### 8. 需求釐清助手
-*   **需求釐清 (`neo:clarification`)**：系統化引導用戶釐清模糊需求，並將其轉化為結構化的規格文件（背景、功能、約束、驗收標準）。
+*   **需求釐清**：系統化引導用戶釐清模糊需求，並將其轉化為結構化的規格文件（背景、功能、約束、驗收標準）。
 
 ### 9. 安全守衛 (Security Guard)
 *   **主動防護 (`secret-guard.ts`)**：作為 CLI 的中介軟體 (Hook)，自動攔截並掃描所有工具執行的參數。若偵測到敏感資訊（如環境設定檔、私鑰、雲端憑證等）將強制阻擋執行，防止機密外洩。
@@ -61,69 +61,145 @@
 
 | 層次 | 目錄 | 描述 |
 | :--- | :--- | :--- |
-| **Server** | `src/server.ts` | 擴充套件的進入點，負責註冊 Tool 與 Prompt，處理與 AI Agent CLI 的通訊。 |
+| **Server** | `src/server.ts` | 擴充套件的進入點，負責註冊 Tool，處理與 AI Agent CLI 的通訊。 |
 | **Knowledge Base** | `skills/` | **"大腦"**。包含各領域知識 (`SKILL.md`) 與可重用的模板 (`templates/`)。 |
-| **Action Registry** | `commands/` | **"指令集"**。定義了使用者可呼叫的具體指令 (TOML 格式)，將請求映射至特定的 Skill。 |
 | **Security Layer** | `src/hooks/` | **"安全守衛"**。攔截並掃描工具執行參數，防止敏感資訊外洩。 |
 
 ## 📦 安裝與使用
 
-本套件支援多種 AI Agent 環境。請依據您的 CLI 工具執行對應指令：
+### 支援的 AI Agent
 
-### Gemini CLI
+| Agent | CLI 工具 | 技能目錄 | 指導檔 |
+| :--- | :--- | :--- | :--- |
+| **Gemini** | [Gemini CLI](https://github.com/google-gemini/gemini-cli) | 透過擴充套件自動載入 | `GEMINI.md` |
+| **Claude** | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | `.claude/skills/` | `CLAUDE.md` |
+| **Copilot** | [GitHub Copilot CLI](https://docs.github.com/en/copilot) | `.copilot/skills/`（全域）<br>`.github/skills/`（專案） | `.copilot/copilot-instructions.md`（全域）<br>`.github/copilot-instructions.md`（專案） |
+| **Codex** | [OpenAI Codex CLI](https://github.com/openai/codex) | `.codex/skills/` | `AGENTS.md` |
+
+Neo Skills 提供兩個 CLI 工具，分別用於安裝**技能模組**與**系統提示詞**：
+
+| 工具 | 用途 | 安裝目標 |
+| :--- | :--- | :--- |
+| `install-skills` | 將技能模組（`skills/`）複製到 Agent 的技能目錄 | 資料夾（如 `.claude/skills`） |
+| `install-system-instructions` | 將系統提示詞寫入 Agent 的指導檔 | 單一檔案（如 `CLAUDE.md`） |
+
+> 兩個工具皆支援 `--ai-agent` 與 `--project-path` 參數，邏輯一致。
+
+---
+
+### 一、Gemini CLI（擴充套件模式）
+
+Gemini CLI 透過擴充套件機制直接安裝，**不需要**以下的 npx 指令：
 
 ```bash
 gemini extension install https://github.com/Benknightdark/neo-skills --auto-update
 ```
 
-### 安裝指定 AI Agent 技能
+---
 
-使用 `--ai-agent` 指定要安裝的 agent（可用值：`claude`、`copilot`、`codex`）：
+### 二、安裝技能模組 (`install-skills`)
+
+將 `skills/` 目錄下的所有技能模組複製到目標 AI Agent 的技能資料夾。
+
+**語法：**
 
-```bash
-npx -p @moon791017/neo-skills install-skills --ai-agent claude
-npx -p @moon791017/neo-skills install-skills --ai-agent copilot
-npx -p @moon791017/neo-skills install-skills --ai-agent codex
 ```
+install-skills [--ai-agent <name>] [--project-path <path>]
+```
+
+**參數：**
 
-### 安裝至指定專案
+| 參數 | 必填 | 說明 |
+| :--- | :---: | :--- |
+| `--ai-agent <name>` | 否 | 指定目標 Agent（`claude` / `copilot` / `codex`）。省略時安裝全部。 |
+| `--project-path <path>` | 否 | 指定專案根目錄。省略時安裝至 `$HOME` 全域路徑。 |
 
-搭配 `--project-path` 可將技能安裝至指定專案目錄（技能子目錄會自動附加）：
+**安裝路徑對照：**
+
+| Agent | 全域路徑 | 專案路徑 |
+| :--- | :--- | :--- |
+| Claude | `~/.claude/skills/` | `<project>/.claude/skills/` |
+| Copilot | `~/.copilot/skills/` | `<project>/.github/skills/` |
+| Codex | `~/.codex/skills/` | `<project>/.codex/skills/` |
+
+**範例：**
 
 ```bash
-# 安裝至 /my/project/.claude/skills
-npx -p @moon791017/neo-skills install-skills --ai-agent claude --project-path /my/project
+# 安裝指定 Agent 至全域
+npx -p @moon791017/neo-skills install-skills --ai-agent claude -y
 
-# 安裝至 /my/project/.github/skills
-npx -p @moon791017/neo-skills install-skills --ai-agent copilot --project-path /my/project
+# 安裝指定 Agent 至專案
+npx -p @moon791017/neo-skills install-skills --ai-agent copilot --project-path /my/project -y
 
-# 安裝至 /my/project/.codex/skills
-npx -p @moon791017/neo-skills install-skills --ai-agent codex --project-path /my/project
+# 一次安裝全部 Agent
+npx -p @moon791017/neo-skills install-skills -y
 ```
 
-若未指定 `--project-path`，則安裝至全域路徑（`~/.claude/skills`、`~/.copilot/skills`、`~/.codex/skills`）。
+---
+
+### 三、安裝系統提示詞 (`install-system-instructions`)
 
-### 安裝全部 AI Agent 技能
+將預定義的系統提示詞寫入 AI Agent 的指導檔。若指導檔已存在，會附加至最下方；若不存在，則自動建立。
 
-不帶 `--ai-agent` 即可一次安裝全部：
+**語法：**
+
+```
+install-system-instructions --ai-agent <name> --instructions <key> [--project-path <path>]
+```
+
+**參數：**
+
+| 參數 | 必填 | 說明 |
+| :--- | :---: | :--- |
+| `--ai-agent <name>` | ✅ | 指定目標 Agent（`claude` / `copilot` / `codex`）。 |
+| `--instructions <key>` | ✅ | 指定要安裝的系統提示詞（見下方種類表）。 |
+| `--project-path <path>` | 否 | 指定專案根目錄。省略時安裝至 `$HOME` 全域路徑。 |
+
+**指導檔路徑對照：**
+
+| Agent | 全域路徑 | 專案路徑 |
+| :--- | :--- | :--- |
+| Claude | `~/.claude/CLAUDE.md` | `<project>/CLAUDE.md` |
+| Copilot | `~/.copilot/copilot-instructions.md` | `<project>/.github/copilot-instructions.md` |
+| Codex | `~/.codex/AGENTS.md` | `<project>/AGENTS.md` |
+
+**可用的系統提示詞種類：**
+
+| Key | 名稱 | 說明 |
+| :--- | :--- | :--- |
+| `technical-co-founder` | Technical Co-Founder | 讓 AI 扮演技術共同創辦人，以 Discovery → Planning → Building → Polish → Handoff 五階段框架，協助您從零打造可上線的真實產品。 |
+
+**範例：**
 
 ```bash
-npx -p @moon791017/neo-skills install-skills
+# 安裝至專案的 CLAUDE.md
+npx -p @moon791017/neo-skills install-system-instructions \
+  --ai-agent claude --instructions technical-co-founder --project-path /my/project -y
+
+# 安裝至專案的 .github/copilot-instructions.md
+npx -p @moon791017/neo-skills install-system-instructions \
+  --ai-agent copilot --instructions technical-co-founder --project-path /my/project -y
+
+# 安裝至全域 (~/.claude/CLAUDE.md)
+npx -p @moon791017/neo-skills install-system-instructions \
+  --ai-agent claude --instructions technical-co-founder -y
 ```
 
+> **💡** 重複執行相同指令不會重複寫入，系統會自動偵測並跳過已安裝的提示詞。
+
 ## 💡 常用指令範例
 
 您可以直接對 AI 代理下達以下指令或在對話中描述需求：
 
-| 需求場景 | 推薦指令 / 咒語範例 |
+| 需求場景 | 推薦咒語範例 |
 | :--- | :--- |
-| **生成 Commit Message** | `幫我 commit 變更` 或 `/neo:git-commit` |
-| **設定 .NET CI Pipeline** | `幫這個專案設定 CI 流程` 或 `/neo:ci-dotnet` |
-| **部署至 IIS** | `部署到 IIS，站台名稱為 MySite` 或 `/neo:cd-iis` |
-| **需求釐清與規格化** | `我想做一個電商網站` 或 `/neo:clarification` |
-| **全方位程式碼審查** | `幫我 code review 剛才的修改` 或 `/neo:code-review` |
-| **生成 C# Interface** | `幫我針對這個 class 產生介面` 或 `/neo:dotnet-gen-interface` |
-| **技術解析與架構洞察** | `分析這個專案的架構` 或 `/neo:explain` |
+| **生成 Commit Message** | `幫我 commit 變更` |
+| **設定 .NET CI Pipeline** | `幫這個專案設定 CI 流程` |
+| **部署至 IIS** | `部署到 IIS，站台名稱為 MySite` |
+| **需求釐清與規格化** | `我想做一個電商網站` |
+| **全方位程式碼審查** | `幫我 code review 剛才的修改` |
+| **生成 C# Interface** | `幫我針對這個 class 產生介面` |
+| **技術解析與架構洞察** | `分析這個專案的架構` |
 
 ## 🛠 開發指南
 

package/bin/_system-instructions.js

@@ -0,0 +1,58 @@
+export const technicalCoFounderInstructions = `Role:
+You are now my Technical Co-Founder. Your job is to help me build a real product I can use, share, or launch. Handle all the building, but keep me in the loop and in control.
+My Idea:
+[Describe your product idea — what it does, who it's for, what problem it solves. Explain it like you'd tell a friend.]
+How serious I am:
+[Just exploring / I want to use this myself / I want to share it with others / I want to launch it publicly]
+Project Framework:
+1. Phase 1: Discovery
+• Ask questions to understand what I actually need (not just what I said)
+• Challenge my assumptions if something doesn't make sense
+• Help me separate "must have now" from "add later"
+• Tell me if my idea is too big and suggest a smarter starting point
+2. Phase 2: Planning
+• Propose exactly what we'll build in version 1
+• Explain the technical approach in plain language
+• Estimate complexity (simple, medium, ambitious)
+• Identify anything I'll need (accounts, services, decisions)
+• Show a rough outline of the finished product
+3. Phase 3: Building
+• Build in stages I can see and react to
+• Explain what you're doing as you go (I want to learn)
+• Test everything before moving on
+• Stop and check in at key decision points
+• If you hit a problem, tell me the options instead of just picking one
+4. Phase 4: Polish
+• Make it look professional, not like a hackathon project
+• Handle edge cases and errors gracefully
+• Make sure it's fast and works on different devices if relevant
+• Add small details that make it feel "finished"
+5. Phase 5: Handoff
+• Deploy it if I want it online
+• Give clear instructions for how to use it, maintain it, and make changes
+• Document everything so I'm not dependent on this conversation
+• Tell me what I could add or improve in version 2
+6. How to Work with Me
+• Treat me as the product owner. I make the decisions, you make them happen.
+• Don't overwhelm me with technical jargon. Translate everything.
+• Push back if I'm overcomplicating or going down a bad path.
+• Be honest about limitations. I'd rather adjust expectations than be disappointed.
+• Move fast, but not so fast that I can't follow what's happening.
+Rules:
+• I don't just want it to work—I want it to be something I'm proud to show people
+• This is real. Not a mockup. Not a prototype. A working product.
+• Keep me in control and in the loop at all times`;
+
+/**
+ * 系統提示詞 Registry — 以 kebab-case 作為 key，供 CLI 選擇安裝。
+ *
+ * 新增提示詞時：
+ *   1. 在上方新增 named export（內容字串）
+ *   2. 在此 registry 加入對應 entry
+ */
+export const INSTRUCTIONS = {
+  'technical-co-founder': {
+    name: 'Technical Co-Founder',
+    content: technicalCoFounderInstructions,
+  },
+};

package/bin/_utils.js

@@ -25,17 +25,29 @@ export const AGENTS = {
   claude: {
     name: 'Claude',
     homePath: '.claude/skills',
+    instructionFile: {
+      homePath: '.claude/CLAUDE.md',
+      projectPath: 'CLAUDE.md',
+    },
     hint: '請確保您的 Claude Desktop 或相關插件已指向此目錄。',
   },
   copilot: {
     name: 'Copilot',
     homePath: '.copilot/skills',
     projectPath: '.github/skills',
+    instructionFile: {
+      homePath: '.copilot/copilot-instructions.md',
+      projectPath: '.github/copilot-instructions.md',
+    },
     hint: '請確保您的 GitHub Copilot CLI 已指向此目錄。',
   },
   codex: {
     name: 'Codex',
     homePath: '.codex/skills',
+    instructionFile: {
+      homePath: '.codex/AGENTS.md',
+      projectPath: 'AGENTS.md',
+    },
     hint: '請確保您的 Codex CLI 已指向此目錄。',
   },
 };

package/bin/install-system-instructions.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * Neo Skills — 系統提示詞安裝程式
+ *
+ * 用法：
+ *   install-system-instructions --ai-agent claude --instructions technical-co-founder
+ *   install-system-instructions --ai-agent copilot --instructions technical-co-founder --project-path .
+ *
+ * 參數：
+ *   --ai-agent <name>         指定目標 AI Agent（可用值見 _utils.js 的 AGENTS）。必填。
+ *   --instructions <key>      指定要安裝的系統提示詞（可用值見 _system-instructions.js 的 INSTRUCTIONS）。必填。
+ *   --project-path <path>     指定專案根目錄作為安裝基底（取代 $HOME）。省略時安裝至全域路徑。
+ */
+import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
+import { join, resolve, dirname } from 'node:path';
+import { homedir } from 'node:os';
+
+import { AGENTS } from './_utils.js';
+import { INSTRUCTIONS } from './_system-instructions.js';
+
+/**
+ * 從 process.argv 解析指定 flag 的值。
+ * @param {string} flag
+ * @returns {string | undefined}
+ */
+function parseArg(flag) {
+  const idx = process.argv.indexOf(flag);
+  if (idx === -1 || idx + 1 >= process.argv.length) return undefined;
+  return process.argv[idx + 1];
+}
+
+/**
+ * 產生提示詞的起始標記。
+ * @param {string} key
+ */
+function startMarker(key) {
+  return `<!-- neo-skills:system-instructions:${key} -->`;
+}
+
+/**
+ * 產生提示詞的結束標記。
+ * @param {string} key
+ */
+function endMarker(key) {
+  return `<!-- /neo-skills:system-instructions:${key} -->`;
+}
+
+/**
+ * 將提示詞包裹在起始/結束標記之間。
+ * @param {string} key
+ * @param {string} content
+ */
+function wrapContent(key, content) {
+  return `${startMarker(key)}\n${content}\n${endMarker(key)}`;
+}
+
+// 全域錯誤攔截
+process.on('uncaughtException', (err) => {
+  console.error('💥 [Fatal Error]:', err);
+  process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+  console.error('💥 [Unhandled Rejection]:', reason);
+  process.exit(1);
+});
+
+async function main() {
+  const agentKey = parseArg('--ai-agent');
+  const projectPath = parseArg('--project-path');
+  const instructionsKey = parseArg('--instructions');
+
+  // ── 驗證 --ai-agent ──
+  if (!agentKey) {
+    const valid = Object.keys(AGENTS).join(', ');
+    console.error(`❌ 缺少必填參數 --ai-agent。可用選項: ${valid}`);
+    process.exit(1);
+  }
+
+  const agentConfig = AGENTS[agentKey];
+  if (!agentConfig) {
+    const valid = Object.keys(AGENTS).join(', ');
+    console.error(`❌ 未知的 agent: "${agentKey}"。可用選項: ${valid}`);
+    process.exit(1);
+  }
+
+  if (!agentConfig.instructionFile) {
+    console.error(`❌ agent "${agentKey}" 未設定 instructionFile。`);
+    process.exit(1);
+  }
+
+  // ── 驗證 --instructions ──
+  if (!instructionsKey) {
+    const valid = Object.keys(INSTRUCTIONS).join(', ');
+    console.error(`❌ 缺少必填參數 --instructions。可用選項: ${valid}`);
+    process.exit(1);
+  }
+
+  const instruction = INSTRUCTIONS[instructionsKey];
+  if (!instruction) {
+    const valid = Object.keys(INSTRUCTIONS).join(', ');
+    console.error(`❌ 未知的 instructions: "${instructionsKey}"。可用選項: ${valid}`);
+    process.exit(1);
+  }
+
+  // ── 決定指導檔路徑 ──
+  const { instructionFile } = agentConfig;
+  const baseDir = projectPath ? resolve(projectPath) : homedir();
+  const subPath = projectPath && instructionFile.projectPath
+    ? instructionFile.projectPath
+    : instructionFile.homePath;
+  const targetFile = join(baseDir, subPath);
+
+  console.log(`🚀 [${agentConfig.name}] 開始安裝系統提示詞: ${instruction.name}`);
+  console.log(`🎯 目標檔案: ${targetFile}`);
+
+  // ── 組裝標記包裹的提示詞內容 ──
+  const wrappedContent = wrapContent(instructionsKey, instruction.content);
+
+  // ── 檢查指導檔是否已存在 ──
+  let fileExists = false;
+  try {
+    await access(targetFile);
+    fileExists = true;
+  } catch {
+    // 檔案不存在，稍後建立
+  }
+
+  if (fileExists) {
+    // 讀取現有內容
+    const existing = await readFile(targetFile, 'utf8');
+
+    // 冪等性檢查：如果已包含相同提示詞的標記，則跳過
+    if (existing.includes(startMarker(instructionsKey))) {
+      console.log(`⏭️  指導檔中已包含 "${instruction.name}" 提示詞，跳過安裝。`);
+      return;
+    }
+
+    // 附加至最下方
+    const newContent = existing.trimEnd() + '\n\n' + wrappedContent + '\n';
+    await writeFile(targetFile, newContent, 'utf8');
+    console.log(`✅ [${agentConfig.name}] 已將 "${instruction.name}" 附加至既有指導檔。`);
+  } else {
+    // 建立目錄結構
+    await mkdir(dirname(targetFile), { recursive: true });
+
+    // 建立新檔案並寫入
+    await writeFile(targetFile, wrappedContent + '\n', 'utf8');
+    console.log(`✅ [${agentConfig.name}] 已建立指導檔並寫入 "${instruction.name}" 提示詞。`);
+  }
+}
+
+main();

package/gemini-extension.json

@@ -1,7 +1,7 @@
 {
   "name": "neo-skills",
   "description": "A universal capability extension for Gemini CLI",
-  "version": "0.47.3",
+  "version": "0.48.0",
   "mcpServers": {
     "neo-skills": {
       "command": "node",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moon791017/neo-skills",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "type": "module",
   "description": "Neo Skills: A Universal Expert Agent Extension",
   "homepage": "https://neo-blog-iota.vercel.app/",
@@ -8,11 +8,13 @@
     "gemini cli",
     "claude code",
     "copilot cli",
+    "openai codex cli",
     "ai agent skills"
   ],
   "bin": {
     "neo-skills": "./bin/install-skills.js",
-    "install-skills": "./bin/install-skills.js"
+    "install-skills": "./bin/install-skills.js",
+    "install-system-instructions": "./bin/install-system-instructions.js"
   },
   "files": [
     "dist",

package/skills/neo-azure-pipelines/SKILL.md

@@ -32,6 +32,8 @@ compatibility: "Supports .NET 6.0 up to .NET 10.0."
     *   If artifact manipulation is required, prioritize using `util/extract-artifact.yml`.
 
 ## Act
+
+### General Output Standards
 1. Output global YAML configuration scripts that comply with the latest Azure DevOps Schema standards.
 2. Provide comprehensive parameter definitions to increase the flexibility and reusability of Pipeline execution.
 3. Generate configuration recommendations for Environments and Approvals and Checks.
@@ -42,4 +44,30 @@ compatibility: "Supports .NET 6.0 up to .NET 10.0."
    - template: skills/neo-azure-pipelines/templates/build/build-dotnet.yml
      parameters:
        buildConfiguration: 'Release'
-   ```
+   ```
+
+### CI Workflow: .NET Build Pipeline
+When configuring a CI process for a .NET project:
+1. Scan the project directory to identify the .NET version (e.g., .NET 6/8), project name, and solution file (`.sln`).
+2. Check for any existing pipeline configurations.
+3. Create the `.pipelines/templates/build/` and `.pipelines/templates/util/` directories.
+4. Copy `build/build-dotnet.yml` and `util/clean-artifact.yml` templates to their respective locations.
+5. Generate `azure-pipelines-ci.yml` in the project root, ensuring the structure uses proper `template` syntax with correct parameters.
+
+### CD Workflow: Azure App Service Deployment
+When configuring a CD process for Azure App Service:
+1. Confirm the Azure App Service name, environment name (e.g., Production/Staging), and Service Connection name with the user or from the project context.
+2. Identify the Build Artifact name.
+3. Copy `deploy/deploy-app-service.yml` to the project's `.pipelines/templates/deploy/` directory.
+4. Generate the deployment pipeline file (e.g., `azure-pipelines-cd-appservice.yml`) in the project root.
+5. Ensure the YAML correctly configures `environment`, `strategy: runOnce`, and template calls.
+6. Advise the user on setting up corresponding Environments and Approvals in Azure DevOps.
+
+### CD Workflow: On-Premises IIS Deployment
+When configuring a CD process for on-premises IIS:
+1. Confirm IIS parameters: Website Name, Physical Path, Deployment Group name, and target environment.
+2. Verify if the project requires specific ASP.NET Core environment settings.
+3. Copy the entire `util/iis/` directory and the `deploy/deploy-iis.yml` template to the project's `.pipelines/templates/` directory.
+4. Generate the deployment script (e.g., `azure-pipelines-cd-iis.yml`) in the project root, referencing `deploy-iis.yml` with parameters like `websiteName` and `physicalPath`.
+5. Ensure the script integrates `iis-backup.yml` and `iis-rollback.yml` logic.
+6. Explain the requirements for Service Connection permissions and Deployment Group configuration.

package/skills/neo-clarification/SKILL.md

@@ -17,6 +17,17 @@ description: 系統化引導使用者釐清模糊需求，並將其轉換為結
 4. Prioritize questions, focusing first on high-weight questions that affect the architecture and core objectives.
 
 ## Act
-1. Execute Phase 1 (Clarification): Output a maximum of 3 structured questions and provide example options to reduce the user's cognitive load.
-2. Execute Phase 2 (Convergence): Consolidate the confirmed information and output a standardized requirement specification document.
-3. Output formatting rules: The specification document must strictly include four basic dimensions: "Background & Purpose", "Core Features", "Constraints", and "Acceptance Criteria".
+
+### Output Language
+All output must be in **Traditional Chinese (Taiwan)**.
+
+### Phase 1 — Clarification
+When key information is missing, output a maximum of **3 structured questions**. Provide example options for each to reduce the user's cognitive load.
+
+### Phase 2 — Convergence
+When information is sufficient, consolidate confirmed information and output a standardized requirement specification document. The document must strictly include the following four dimensions:
+
+1. **背景與目的 (Background & Purpose)**
+2. **核心功能 (Core Features)**
+3. **約束條件 (Constraints)**
+4. **驗收標準 (Acceptance Criteria)**

package/skills/neo-code-review/SKILL.md

@@ -6,12 +6,18 @@ description: 分析程式碼變更，從安全性、效能與風格等多個面
 # Code Review Specifications
 
 ## Perceive (Analysis Phase)
-1. **Scope Identification**:
+1. **Input Handling**:
+   - If no specific files or code content is provided, execute `git diff HEAD` to retrieve all staged and unstaged changes.
+   - If `git diff` returns empty, inform the user: "No changes detected." and stop.
+   - If specific file paths are provided, read those files.
+   - If raw code content is provided, use it directly.
+
+2. **Scope Identification**:
    - Analyze the provided code diffs or file contents.
    - Identify the languages and frameworks involved (e.g., TypeScript, C#, Python, React).
    - Determine the nature of the change (e.g., Feature, Bugfix, Refactor, Config).
 
-2. **Context Gathering**:
+3. **Context Gathering**:
    - Look for surrounding code to understand the impact of changes.
    - Check for relevant configuration files (e.g., `tsconfig.json`, `.eslintrc`, security policies) if available in the provided context.
 

package/skills/neo-csharp-interface-generator/SKILL.md

@@ -38,3 +38,4 @@ compatibility: "Supports C# 12/13 and .NET 10.0."
 3. **Execution Write**:
    - Based on the user's response, perform `read_file` (if the file exists) -> logical replacement -> `write_file`.
    - Inform the user of the result (created, appended, or overwritten).
+4. **Output Language**: The final output to the user must be in **Traditional Chinese (Taiwan)**.

package/skills/neo-explain/SKILL.md

@@ -18,10 +18,22 @@ description: 分析原始碼或專案結構，提供技術解析與架構洞察
 4. Documentation Alignment: Compare the implementation against common design patterns to explain "why" the code is structured in its current form.
 
 ## Act
-1. Output a structured explanation directly to the terminal's standard output (stdout).
-2. Format the response using the following hierarchy:
-   - Summary: High-level purpose of the code.
-   - Logic Flow: Step-by-step breakdown of execution and data flow.
-   - Key Components: Definitions of primary symbols and their roles.
-3. Apply syntax highlighting to any code blocks included within the explanation.
-4. Return non-zero exit codes if the target file is missing or the content exceeds the model's context window.
+
+### Output Language
+All output must be in **Traditional Chinese (Taiwan)**.
+
+### Output Format
+Structure the response using the following hierarchy:
+
+#### 📝 Summary
+High-level purpose and core objectives of the code.
+
+#### ⚙️ Logic Flow
+Step-by-step breakdown of execution, explaining data flow or control flow.
+
+#### 🧩 Key Components
+Definitions of primary symbols, classes, or functions and their roles.
+
+### Additional Rules
+1. Apply syntax highlighting to any code blocks included within the explanation.
+2. If the target file is missing or the content exceeds the model's context window, inform the user accordingly.

package/skills/neo-git-commit/SKILL.md

@@ -11,6 +11,7 @@ disable-model-invocation: true
 - **Absolute prohibition**: Never execute `git commit` in the same turn you generate the commit message.
 - **Wait for confirmation**: Output the proposed message, then stop immediately and ask the user to confirm.
 - **User-triggered only**: Only execute the commit in the next turn if the user explicitly replies with "yes", "ok", "是", or "commit".
+- **No commit trailers**: Do **not** generate or append any commit trailer lines such as `Co-authored-by:`, `Signed-off-by:`, `Reviewed-by:`, or similar metadata unless the user explicitly requests them.
 
 ---
 
@@ -66,6 +67,7 @@ Output strictly in the following format:
   - For new files, describe their purpose.
 - **Language**: Both Subject and Body must be written in **Traditional Chinese (Taiwan)**.
 - **Tone**: Professional and concise — avoid filler phrases like "This change is for...".
+- **Forbidden content**: Do **not** include `Co-authored-by`, `Signed-off-by`, or any other trailer/footer metadata in the generated commit message.
 
 ### Step 2: Ask for confirmation
 
@@ -81,4 +83,6 @@ Run:
 git commit -m "<subject>" -m "<body>"
 ```
 
+Do not append any extra trailer/footer metadata unless the user explicitly requests it.
+
 After execution, run `git log --oneline -1` and display the result to confirm the commit was created successfully.

package/skills/neo-start-plan/SKILL.md

@@ -12,7 +12,7 @@ description: 分析需求與專案現況，並生成詳細的開發執行計畫
 
 ## Reason
 1. **Gap Analysis**: Clearly define the delta between the current codebase state and the user's desired state.
-2. **Architectural Fit**: Ensure the proposed solution aligns with the established architecture (e.g., separating logic into `skills/`, using `commands/` for entry points).
+2. **Architectural Fit**: Ensure the proposed solution aligns with the established architecture (e.g., separating logic into `skills/`).
 3. **Risk Assessment**: Identify potential breaking changes, ambiguous requirements, or side effects.
 4. **Dependency Chain**: Determine the strictly logical order of operations (e.g., "Create directory before creating file").
 

package/commands/neo/cd-app-service.toml

@@ -1,20 +0,0 @@
-description = "為專案自動配置 Azure App Service 的部署流程 (CD)"
-
-prompt = """
-Act as a **Senior DevOps Architect** to configure the Continuous Deployment (CD) process for Azure App Service:
-
-1. **Perceive**:
-   - Read `skills/neo-azure-pipelines/SKILL.md` to load design specifications.
-   - Confirm the Azure App Service name, environment name (e.g., Production/Staging), and Service Connection name with the user or from the project context.
-   - Identify the Build Artifact name.
-
-2. **Reason**:
-   - Plan to copy `skills/neo-azure-pipelines/templates/deploy/deploy-app-service.yml` to the project's `.pipelines/templates/deploy/` directory.
-   - Design the YAML script referencing the deployment template according to `SKILL.md` standards.
-
-3. **Act**:
-   - Create directories and copy the deployment templates to the project.
-   - Generate the deployment pipeline file (e.g., `azure-pipelines-cd-appservice.yml`) in the project root.
-   - Ensure the YAML correctly configures `environment`, `strategy: runOnce`, and template calls.
-   - Advise the user on setting up corresponding Environments and Approvals in Azure DevOps.
-"""

package/commands/neo/cd-iis.toml

@@ -1,20 +0,0 @@
-description = "為專案自動配置地端 IIS 的部署流程 (CD)"
-
-prompt = """
-Act as a **Senior DevOps Architect** to configure the Continuous Deployment (CD) process for On-Premises IIS:
-
-1. **Perceive**:
-   - Read `skills/neo-azure-pipelines/SKILL.md` to load design specifications.
-   - Confirm IIS parameters: Website Name, Physical Path, Deployment Group name, and target environment.
-   - Verify if the project requires specific ASP.NET Core environment settings.
-
-2. **Reason**:
-   - Plan to copy the entire `skills/neo-azure-pipelines/templates/util/iis/` directory and the `deploy/deploy-iis.yml` template.
-   - Design a pipeline with staged tasks including backup and rollback logic as required by `SKILL.md`.
-
-3. **Act**:
-   - Copy all necessary IIS deployment templates to the project's `.pipelines/templates/` directory.
-   - Generate the deployment script (e.g., `azure-pipelines-cd-iis.yml`) in the project root, referencing `deploy-iis.yml` with parameters like `websiteName` and `physicalPath`.
-   - Ensure the script integrates `iis-backup.yml` and `iis-rollback.yml` logic.
-   - Explain the requirements for Service Connection permissions and Deployment Group configuration.
-"""

package/commands/neo/ci-dotnet.toml

@@ -1,21 +0,0 @@
-description = "自動配置 .NET 專案的 Azure Pipelines CI 建置流程"
-
-prompt = """
-Act as a **Senior DevOps Architect** to configure the Azure Pipelines CI process for this .NET project:
-
-1. **Perceive**:
-   - Read `skills/neo-azure-pipelines/SKILL.md` to load design specifications.
-   - Scan the project directory to identify the .NET version (e.g., .NET 6/8), project name, and solution file (.sln).
-   - Check for any existing pipeline configurations.
-
-2. **Reason**:
-   - Determine the build strategy based on `SKILL.md` guidelines.
-   - Plan to copy `skills/neo-azure-pipelines/templates/build/build-dotnet.yml` and relevant `util` templates to the `.pipelines/templates/` directory within the project.
-   - Design the main pipeline file (e.g., `azure-pipelines-ci.yml`) to reference these templates with the correct parameters.
-
-3. **Act**:
-   - Create the `.pipelines/templates/build/` and `.pipelines/templates/util/` directories.
-   - Copy `skills/neo-azure-pipelines/templates/build/build-dotnet.yml` and `skills/neo-azure-pipelines/templates/util/clean-artifact.yml` to their respective locations.
-   - Generate `azure-pipelines-ci.yml` in the project root, ensuring the structure complies with `SKILL.md` and uses proper `template` syntax.
-   - Provide a brief explanation of the configuration and how to use it.
-"""

package/commands/neo/clarification.toml

@@ -1,48 +0,0 @@
-description = "系統化引導用戶釐清模糊需求，並將其轉化為結構化的規格文件。"
-
-prompt = """
-# Role: Requirement Clarification Assistant
-
-You are an expert Requirement Clarification Assistant. Your goal is to systematically guide users to clarify vague requirements and convert them into structured specification documents.
-
-## Mission Context
-The user has provided a requirement or task description:
-> {{args}}
-
-You must analyze this input and decide whether to ask clarifying questions or generate a formal specification.
-
-## Operational Protocol (Perceive-Reason-Act)
-
-1. **Perceive (Context Awareness)**:
-   - **Read and internalize the guidelines in `skills/neo-clarification/SKILL.md`.**
-   - Identify the professional domain context.
-   - Extract confirmed objectives, constraints, and stakeholder information.
-
-2. **Reason (Gap Analysis)**:
-   - Map information against 5W1H or SMART criteria as defined in the Skill.
-   - Identify missing key information, logical conflicts, and undefined boundary conditions.
-   - Determine the current phase:
-     - **Phase 1 (Clarification)**: If key information is missing.
-     - **Phase 2 (Convergence)**: If information is sufficient for a specification.
-
-3. **Act (Execution Phase)**:
-   - Follow the execution phase rules and formatting defined in `skills/neo-clarification/SKILL.md`.
-   - **If Phase 1**: Output a maximum of 3 structured questions. Provide example options for each to reduce the user's cognitive load.
-   - **If Phase 2**: Consolidate information and output a standardized requirement specification document.
-
-## Strict Output Rules (Traditional Chinese)
-
-Please output in **Traditional Chinese (Taiwan)**.
-
-### Specification Document Format (Only for Phase 2)
-The specification document must strictly include the four dimensions defined in the Skill:
-- **背景與目的 (Background & Purpose)**
-- **核心功能 (Core Features)**
-- **約束條件 (Constraints)**
-- **驗收標準 (Acceptance Criteria)**
-
----
-
-## User Input
-{{args}}
-"""

package/commands/neo/code-review.toml

@@ -1,33 +0,0 @@
-description = "對當前變更或指定檔案進行全方位的程式碼審查"
-prompt = """
-# Role: Senior Code Reviewer
-
-You are an expert Senior Software Engineer and Architect. Your task is to perform a thorough code review based on the provided code changes.
-
-## Mission Context
-The user has requested a code review. You will receive the code changes (usually from `git diff` or file contents). You must analyze these changes strictly following the expert guidelines.
-
-## Process
-1. **Perceive**: Read and internalize the guidelines in `skills/neo-code-review/SKILL.md`.
-2. **Analyze**: Examine the input code changes in `{{args}}`.
-   - If `{{args}}` is empty or generic, assume the input is the current staged and unstaged changes (you may need to ask the user to provide them or run `git diff` yourself if the context isn't automatically provided, but typically the tool wrapper handles this. *Self-correction*: As a prompt for an agent, I should treat `{{args}}` as the text to review. If it's empty, I should instruct the agent to *find* the changes using tools like `run_shell_command("git diff")`.)
-3. **Reason**: Evaluate the code against the dimensions defined in the Skill (Logic, Security, Performance, Maintainability).
-4. **Act**: Output a structured Code Review Report in **Traditional Chinese (Taiwan)**.
-
-## Execution Steps for Agent
-If `{{args}}` is empty:
-1. Execute `git diff HEAD` to get all changes (staged and unstaged).
-2. If `git diff` is empty, inform the user "No changes detected."
-3. If changes exist, proceed with the review.
-
-If `{{args}}` is NOT empty:
-1. Treat `{{args}}` as the specific file paths or the raw code content to review.
-2. If they are file paths, read them.
-3. Proceed with the review.
-
-## Output Format
-Strictly follow the "Act (Reporting Phase)" section in `skills/neo-code-review/SKILL.md`.
-
-## Input Data
-User Arguments: {{args}}
-"""

package/commands/neo/dotnet-gen-interface.toml

@@ -1,31 +0,0 @@
-description = "針對指定的 C# 類別生成對應的 Interface，並提供智慧覆蓋功能"
-
-prompt = """
-# Role: Senior .NET Software Engineer
-
-You are a senior engineer proficient in .NET architecture. Your task is to assist users in converting C# Classes to Interfaces, ensuring code quality and project cleanliness.
-
-## Mission Context
-The user has provided a C# Class, and you need to generate an Interface for it.
-Target Content: {{args}}
-
-## Step 1: Perceive & Reason (Generation Phase)
-1. Refer to the specifications in `skills/neo-csharp-interface-generator/SKILL.md`.
-2. **Strict Filtering**:
-   - Extract only `public` properties.
-   - **Absolutely no** `virtual` properties.
-   - **Getter Only**: All properties must only have `{ get; }`. **Strictly forbid** `{ get; set; }` or any `set`/`init` accessors.
-   - The name must be the Class name prefixed with `I`.
-3. Generate the complete Interface code block.
-
-## Step 2: Act (Response Phase)
-1. Output the generated Interface code.
-2. **Must explicitly ask**: "In which file should this Interface be stored? (e.g., Interfaces/IUser.cs)".
-
-## Step 3: Handle Subsequent Saving (Smart Overwrite)
-When the user provides a path, perform the following:
-1. Check if the file exists.
-2. If it exists, check if it already contains an `interface` with the same name.
-3. If it does, precisely replace that block; otherwise, append or create it.
-4. **The final output to the user MUST be in Traditional Chinese (Taiwan).**
-"""

package/commands/neo/explain.toml

@@ -1,44 +0,0 @@
-description = "分析原始碼或專案結構，提供技術解析與架構洞察"
-
-prompt = """
-# Role: Senior Technical Lead & Architect
-
-You are an expert software architect. Your task is to analyze source code or project structures to provide clear, deep technical explanations and architectural insights.
-
-## Mission Context
-The user has requested an explanation for:
-> {{args}}
-
-## Process
-1. **Perceive**:
-   - Read and internalize the guidelines in `skills/neo-explain/SKILL.md`.
-   - Identify the target files, directories, or code segments from `{{args}}`.
-   - If `{{args}}` is empty, analyze the current active file or project structure as context.
-
-2. **Reason**:
-   - **Structural Parsing**: Map relationships between variables, functions, and classes in the context.
-   - **Logic Synthesis**: Consolidate fragmented code segments into a coherent operational flow.
-   - **Contextual Inference**: Evaluate how the specific code block interacts with standard libraries or identified project dependencies.
-   - **Design Alignment**: Explain the implementation motivation from the perspective of design patterns.
-
-3. **Act**:
-   - Provide a structured explanation according to the guidelines in `skills/neo-explain/SKILL.md`.
-   - **The output MUST be in Traditional Chinese (Taiwan).**
-
-## Output Format
-Please follow this structure:
-
-### 📝 Summary
-(Explain the high-level purpose and core objectives of the code)
-
-### ⚙️ Logic Flow
-(Step-by-step breakdown of execution, explaining data flow or control flow)
-
-### 🧩 Key Components
-(Define primary symbols, classes, or functions and their roles)
-
----
-
-## User Request
-{{args}}
-"""

package/commands/neo/git-commit.toml

@@ -1,49 +0,0 @@
-description = "Automatically generate a Conventional Commit message based on staged changes."
-prompt = """
-# Role: Senior Git Commit Message Generator
-
-You are a senior software architect with extremely high standards for code quality. Your expertise lies in precisely distilling the core intent of changes from messy code modifications.
-
-# CRITICAL SAFETY PROTOCOL
-- **ABSOLUTE PROHIBITION**: You are STRICTLY FORBIDDEN from executing the `git commit` command in the same turn that you generate the commit message.
-- **WAIT FOR CONFIRMATION**: You MUST output the proposed commit message and then STOP. You must explicitly ask the user for confirmation (e.g., "Do you want to execute this commit?").
-- **USER TRIGGER ONLY**: The `run_shell_command` to execute `git commit` can ONLY be triggered in the *next* turn, and ONLY if the user explicitly replies with "yes", "ok", or "commit".
-
-## Mission Context
-The command `git add .` has been automatically executed, staging all changes (including new files, modifications, and deletions) in the working directory.
-You will receive the full output of `git diff --staged`. Please analyze these code changes and write a perfectly structured, semantically clear Commit Message.
-
-## Analysis Steps
-1. **Holistic Scan**: Identify which files have been added, deleted, or modified.
-2. **Find Correlations**: Determine if these changes serve a single goal (e.g., adding a Model and updating a Service indicates a feature implementation).
-3. **Filter Noise**: Ignore formatting tweaks (like whitespace) and focus on logical changes.
-4. **Define Type**: Choose the type (feat, fix, refactor, etc.) based on the "primary purpose" of the changes.
-
-## Strict Output Rules
-1. **Follow Conventional Commits Format**:
-   `<type>(<scope>): <subject>`
-   
-   `<body>`
-2. **Language Requirements**:
-   - The **Subject** and **Body** MUST be in **Traditional Chinese (Taiwan)**.
-   - Use a professional, concise tone; avoid filler words (e.g., "This change is for...").
-3. **Content Requirements**:
-   - **Type**: Select the most accurate one from [feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert].
-   - **Scope**: (Optional) The module or layer affected (e.g., `auth`, `repo`, `ui`).
-   - **Subject**: Maximum 50 characters, use imperative mood (e.g., "新增...", "修復...").
-   - **Body**:
-     - For complex changes, use bullet points (`-`) to explain specific details.
-     - For simple documentation or minor fixes, the Body may be omitted.
-     - **For new files**, explain their purpose.
-4. **Output & Confirmation**:
-   - **Output** the generated Commit Message in a code block.
-   - **STOP IMMEDIATELY**. Do not assume consent.
-   - **Ask** the user: "請問是否要執行此 commit？" (Do you want to execute this commit?)
-
-5. **Context Isolation**:
-   - This workflow is **EXCLUSIVE** to the current `/neo:git-commit` command invocation.
-   - In future conversation turns, strictly revert to the standard assistant persona.
-
-## Input Data
-{{args}}
-"""