@moon791017/neo-skills 1.0.1

package/GEMINI.md

@@ -0,0 +1,115 @@
+# 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.
+
+## Constraints
+- All MCP commands must be manually executed by the user and cannot be automated!
+
+## Response Style
+All responses must strictly adhere to the following guidelines and in 「Traditional Taiwanese Chinese」:
+You must engage in "fact-check thinking" before answering. Unless explicitly provided by the user or present in the data, do not assume, speculate, or create content. Strictly based on sources: Use only user-provided content, your internal explicit knowledge, or verified data. If information is insufficient, state "insufficient data" or "I cannot determine" directly; do not guess. Show basis for thinking: If you cite data or infer, explain the paragraph or reason you rely on. If it is personal analysis or estimation, clearly label it as "this is an inference" or "this is a hypothetical scenario". Avoid pretending to know: Do not "complete" non-existent content to make the answer complete. If you encounter vague or incomplete questions, ask for clarification or offer options instead of deciding yourself. Maintain semantic consistency: Do not rewrite or expand the user's original meaning. If you need to restate, explicitly label it as a "restated version" and keep the meaning equivalent. Answer format: If there is clear data, answer with the basis. If there is no clear data, answer "cannot determine" and explain the reason. Do not use vague tones like "should be", "probably", "I guess" unless requested by the user. Depth of thought: Before outputting, check if the answer: a. has a clear basis, b. does not exceed the scope of the question, c. does not mention any names, numbers, events, or assumptions not explicitly mentioned. Final principle: Better blank than fabricated.
+
+## 🚀 Project Overview
+
+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`).
+3.  **Standardize** outputs to ensure consistency and reliability.
+
+## 📂 System Architecture
+
+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.
+*   **Structure:**
+    *   `SKILL.md`: The "Brain". Defines the **Perceive-Reason-Act** loop for the domain. It instructs the agent on how to analyze the environment and make decisions.
+    *   `templates/`: The "Hands". A library of reusable assets that the agent should use instead of writing code from scratch.
+*   **Example:** `skills/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/`)
+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.
+
+## 🛠 Building and Running
+
+This project uses **Bun** for development and building, and **Node.js** for the runtime environment.
+
+### Prerequisites
+*   Node.js (v18+)
+*   Bun
+
+### Commands
+
+*   **Install Dependencies:**
+    ```bash
+    npm install
+    ```
+*   **Build Project:**
+    ```bash
+    bun run build
+    ```
+    *This cleans the `dist` folder and bundles `src/server.ts` into `dist/server.js`.*
+*   **Development Mode:**
+    ```bash
+    bun src/server.ts
+    ```
+*   **Type Check:**
+    ```bash
+    bun run typecheck
+    ```
+
+## 🧩 Extension Configuration
+
+The extension is defined in `gemini-extension.json`:
+*   **Name:** `neo-skills`
+*   **Entry Point:** `dist/server.js`
+*   **Context File:** `GEMINI.md` (This file)
+
+## 💡 Usage Philosophy
+
+When interacting with this codebase or using the extension, the agent follows the **Perceive-Reason-Act** protocol:
+
+1.  **Perceive:** Analyze the user's project context (languages, frameworks, existing config).
+2.  **Reason:** Consult the internal knowledge base (`SKILL.md`) to formulate a strategy.
+3.  **Act:** Execute the workflow, prioritizing the use of existing templates in `skills/**/templates/` over generating new code.
+
+### Available Capabilities (Current Built-in Skills)
+
+*   **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`).
+
+*   **CI Protocols:** 自動配置 .NET 專案的 Azure Pipelines CI 建置流程 (`neo:ci-dotnet`)。
+
+*   **CD Protocols:** 為專案自動配置 Azure App Service (`neo:cd-app-service`) 與地端 IIS (`neo:cd-iis`) 的部署流程 (CD)。
+
+*   **Requirement Clarification:** 系統化引導用戶釐清模糊需求，並將其轉化為結構化的規格文件 (`neo:clarification`)。
+
+*   **Code Explanation:** 分析原始碼或專案結構，提供技術解析與架構洞察 (`neo:explain`)。
+
+*   **Code Review:** 對當前變更或指定檔案進行全方位的程式碼審查 (`neo:code-review`)。
+
+*   **C# 現代語法專家:** 跨版本 C# 專家 (10-14+)，專注於現代化語法、強型別與高效能開發模式。
+
+*   **.NET 開發專家群:** 包含核心環境路由，以及針對 Minimal APIs、Web API、MVC 與 EF Core 的深度技術指引與開發規範。
+
+*   **C# Interface Generation:** 針對指定的 C# 類別生成對應的 Interface，並提供智慧覆蓋功能 (`neo:dotnet-gen-interface`)。
+
+*   **Python 3.10+ 現代開發專家:** 專注於 Python 3.10 至 3.14 的現代語法特性、型別安全與非同步開發。
+
+*   **Python 環境管理專家:** 智慧偵測並管理 Python 專案的虛擬環境與相依套件工具（支援 uv, Poetry, venv/pip）。
+
+*   **Swift 專家:** 支援 Swift 5.0 至 6.0+ 的現代開發模式，涵蓋 SwiftUI、Structured Concurrency 與記憶體安全。
+
+*   **SwiftUI 專家:** 支援 iOS 16.0+ 與 Swift 5.0+ 的現代開發模式，專注於 NavigationStack、Observation 框架、資料流架構及高效能視圖設計。

package/README.md

@@ -0,0 +1,155 @@
+# Neo Skills
+
+**Neo Skills** 是專為現代 **AI Agent** 設計的**全方位能力擴充套件**。本專案透過標準化的通訊架構，為 AI 代理安裝可插拔的「技能模組 (Skills)」，使其不僅僅是一個聊天機器人，而是能轉化為具備「感知-推理-行動」能力的**多領域專家**。
+
+無論是 DevOps 自動化、軟體架構設計，或是未來的資料分析與專案管理，Neo Skills 都能透過掛載不同的知識庫與工具，讓 AI 成為您最強大的全能助手。
+
+## 🚀 核心願景
+
+本專案作為 AI Agent 的「大腦皮層 (Cortex)」，旨在打造一個**全能型 Agent 框架**，透過以下機制提升 AI 的專業度：
+
+1.  **領域專精 (Skills)**：可擴充的專家知識庫 (`SKILL.md`)。目前已內建 DevOps 模組，未來將持續擴增更多領域。
+2.  **標準化執行 (Commands)**：提供預先驗證的自動化腳本與模板，確保產出的一致性與可靠性。
+3.  **架構思維**：強制執行「感知 (Perceive) -> 推理 (Reason) -> 行動 (Act)」的決策迴圈，避免 AI 產生幻覺，確保解決方案的精準度。
+
+## ✨ 目前內建技能 (Built-in Skills)
+
+### 1. Azure Pipelines 架構師
+自動化設計與生成符合微軟最佳實踐的 CI/CD 流程。
+*   **CI 自動化 (`neo:ci-dotnet`)**：針對 .NET 專案生成建置管線，整合單元測試與構件發佈。
+*   **CD 自動化**：
+    *   **Azure App Service (`neo:cd-app-service`)**：部署至Azure App Service。
+    *   **IIS On-Premises (`neo:cd-iis`)**：部署至地端 IIS 伺服器，包含備份與復原機制。
+
+### 2. 智慧 Git 助手
+*   **Smart Commit (`neo:git_commit`)**：根據 `git diff` 暫存區內容，自動生成符合 Conventional Commits 規範的提交訊息。
+
+### 3. Code Review 專家
+*   **智能審查 (`neo:code-review`)**：針對程式碼變更進行多面向 (正確性、安全性、效能、可讀性) 的深度審查。
+
+### 4. 程式碼解釋助手
+*   **技術解析 (`neo:explain`)**：深入分析原始碼或專案結構，提供高階用途摘要、邏輯流程分解以及核心元件說明。
+
+### 5. .NET / C# 開發專家
+*   **C# 現代語法專家 (`skills/csharp`)**：跨版本 C# 專家 (10-14+)，專注於現代化語法、強型別與高效能開發模式。
+*   **.NET 核心路由 (`skills/dotnet`)**：環境偵測與統一入口，自動將任務委派給最合適的子領域專家。
+*   **.NET Minimal APIs 專家 (`skills/dotnet-minimal-apis`)**：專注於高效能微服務、路由群組與 Typed Results。
+*   **.NET Web API 專家 (`skills/dotnet-webapi`)**：提供控制器模式下的架構設計、Problem Details 與異常處理指引。
+*   **.NET MVC 專家 (`skills/dotnet-mvc`)**：處理伺服器端渲染 (SSR)、視圖模型與標籤協助程式的最佳實踐。
+*   **EF Core 專家 (`skills/dotnet-ef-core`)**：專注於資料庫建模、移轉管理與 Linq 查詢優化。
+*   **Interface 生成器 (`neo:dotnet-gen-interface`)**：針對 C# Class 自動生成符合規範的 Interface，並支援智慧檔案覆蓋功能。
+
+### 6. Python 開發與環境管理專家
+*   **Python 3.10+ 專家 (`skills/python`)**：專注於 Python 3.10 至 3.14 的現代語法特性、型別安全與非同步開發。
+*   **環境管理專家 (`skills/python-manager`)**：智慧偵測與管理 Python 專案環境，支援 uv, Poetry, venv/pip 並提供自動化安裝建議。
+
+### 7. Swift 開發專家
+*   **Swift 5.0+ 專家 (`skills/swift`)**：支援從基礎語法到 Swift 6 的現代開發模式，涵蓋 SwiftUI、Structured Concurrency、記憶體安全以及高效能 App 開發指引。
+*   **SwiftUI 專家 (`skills/swift-ui`)**：支援 iOS 16.0+ 與 Swift 5.0+ 的現代開發模式，專注於 NavigationStack、Observation 框架、資料流架構及高效能視圖設計。
+
+### 8. 需求釐清助手
+*   **需求釐清 (`neo:clarification`)**：系統化引導用戶釐清模糊需求，並將其轉化為結構化的規格文件（背景、功能、約束、驗收標準）。
+
+### 9. 安全守衛 (Security Guard)
+*   **主動防護 (`secret-guard.ts`)**：作為 CLI 的中介軟體 (Hook)，自動攔截並掃描所有工具執行的參數。若偵測到敏感資訊（如環境設定檔、私鑰、雲端憑證等）將強制阻擋執行，防止機密外洩。
+
+## 📂 系統架構
+
+本專案由三個核心層次組成，支援無限擴充：
+
+| 層次 | 目錄 | 描述 |
+| :--- | :--- | :--- |
+| **Server** | `src/server.ts` | 擴充套件的進入點，負責註冊 Tool 與 Prompt，處理與 AI Agent CLI 的通訊。 |
+| **Knowledge Base** | `skills/` | **"大腦"**。包含各領域知識 (`SKILL.md`) 與可重用的模板 (`templates/`)。 |
+| **Action Registry** | `commands/` | **"指令集"**。定義了使用者可呼叫的具體指令 (TOML 格式)，將請求映射至特定的 Skill。 |
+| **Security Layer** | `src/hooks/` | **"安全守衛"**。攔截並掃描工具執行參數，防止敏感資訊外洩。 |
+
+## 📦 安裝與使用
+
+本套件目前支援多種 AI Agent CLI 環境。
+
+### 1. Claude Code (或其餘 Agent)
+
+#### 方案 A：透過 Claude Code CLI 安裝
+這是最簡單的方式，直接讓 Claude Code 管理擴充：
+```bash
+claude plugin add https://github.com/Benknightdark/neo-skills
+```
+
+#### 方案 B：透過 git clone 後手動安裝
+```bash
+# 使用 npx 直接執行安裝指令
+git clone https://github.com/Benknightdark/neo-skills.git
+cd neo-skills
+npm install
+node ./bin/install-claude-skills.js
+```
+
+### 2. Gemini CLI 安裝方式 (需安裝 Bun)
+此方式會執行 MCP Server，因此需要先建置專案：
+```bash
+gemini extension install https://github.com/Benknightdark/neo-skills --auto-update
+```
+
+或在配置檔案中手動進行本地路徑配置：
+
+```json
+{
+  "name": "neo-skills",
+  "mcpServers": {
+    "neo-skills": {
+      "command": "node",
+      "args": ["${extensionPath}/dist/server.js"]
+    }
+  }
+}
+```
+
+## 💡 常用指令範例
+
+您可以直接對 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`
+
+## 🛠 開發指南
+
+本專案使用 **Bun** 進行開發與建置。
+
+### 前置需求
+*   **[Node.js](https://nodejs.org/) (v18+)**：基本執行環境。
+*   **[Bun](https://bun.sh/)**：僅在**開發**、**建置**或執行 **Gemini MCP Server** 時需要。
+
+### 快速開始
+
+1.  **安裝依賴**
+    ```bash
+    npm install
+    ```
+
+2.  **開發模式 (Watch Mode)**
+    直接執行原始碼進行測試：
+    ```bash
+    bun src/server.ts
+    ```
+
+3.  **建置專案**
+    將 TypeScript 編譯並打包至 `dist/` 目錄：
+    ```bash
+    bun run build
+    ```
+
+4.  **類型檢查**
+    ```bash
+    bun run typecheck
+    ```

package/bin/install-claude-skills.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { cp, mkdir, access } from 'node:fs/promises';
+import { join, resolve, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+// 立即輸出日誌以確認腳本已啟動
+console.log('🏁 [Debug] 腳本已啟動...');
+
+// 捕捉全域錯誤
+process.on('uncaughtException', (err) => {
+  console.error('💥 [Fatal Error]:', err);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('💥 [Unhandled Rejection]:', reason);
+  process.exit(1);
+});
+
+// 取得當前檔案路徑
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function installClaudeSkills() {
+  try {
+    // 1. 定義來源目錄: 腳本所在目錄的上一層的 skills 資料夾
+    // 當透過 npx 執行時，它會指向臨時下載的 package 內容
+    const packageRoot = resolve(__dirname, '..');
+    const sourceDir = join(packageRoot, 'skills');
+    
+    // 2. 定義目標目錄: ~/.claude/skills (跨平台自動處理)
+    const targetBaseDir = join(homedir(), '.claude');
+    const targetSkillsDir = join(targetBaseDir, 'skills');
+
+    console.log('🚀 [Claude] 開始同步 Neo Skills...');
+    
+    // 檢查來源是否存在
+    try {
+      await access(sourceDir);
+    } catch {
+      console.error(`❌ 錯誤: 在 ${sourceDir} 找不到來源技能目錄。`);
+      process.exit(1);
+    }
+
+    console.log(`📁 來源路徑: ${sourceDir}`);
+    console.log(`🎯 目標路徑: ${targetSkillsDir}`);
+
+    // 3. 確保目標目錄存在 (recursive: true 會自動建立多層目錄)
+    await mkdir(targetSkillsDir, { recursive: true });
+
+    // 4. 執行複製
+    await cp(sourceDir, targetSkillsDir, { 
+      recursive: true, 
+      force: true,
+      // 過濾掉不必要的開發檔案
+      filter: (src) => {
+        const isIgnored = src.includes('node_modules') || src.includes('.git');
+        return !isIgnored;
+      }
+    });
+
+    console.log('✅ [Claude] 安裝成功！技能已同步至 .claude/skills');
+    console.log('💡 提示: 請確保您的 Claude Desktop 或相關插件已指向此目錄。');
+
+  } catch (error) {
+    console.error('❌ [Claude] 安裝失敗:', error.message || error);
+    process.exit(1);
+  }
+}
+
+installClaudeSkills();

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

@@ -0,0 +1,20 @@
+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/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/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

@@ -0,0 +1,20 @@
+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/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/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

@@ -0,0 +1,21 @@
+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/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/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/azure-pipelines/templates/build/build-dotnet.yml` and `skills/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

@@ -0,0 +1,48 @@
+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/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/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

@@ -0,0 +1,33 @@
+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/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/code-review/SKILL.md`.
+
+## Input Data
+User Arguments: {{args}}
+"""

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

@@ -0,0 +1,31 @@
+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/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

@@ -0,0 +1,44 @@
+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/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/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

@@ -0,0 +1,49 @@
+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}}
+"""

package/dist/hooks/secret-guard.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+var b=(g)=>new RegExp(g,"i"),Q=[b("\\.env"),b("\\.pem\\b"),b("\\.key\\b"),b("\\.git[/\\\\]"),b("\\bid_rsa"),b("credentials\\.json"),b("launchSettings\\.json"),b("\\bsecrets?[/\\\\]")];async function U(){try{let z=(await new Promise((q,K)=>{let D=[];process.stdin.on("data",(M)=>D.push(M)),process.stdin.on("end",()=>q(Buffer.concat(D))),process.stdin.on("error",K)})).toString("utf-8").trim();if(!z)throw Error("No input received from Gemini CLI.");for(let q of Q)if(q.test(z))process.stdout.write(JSON.stringify({decision:"deny",reason:"Security Alert: Access to sensitive file matching pattern is blocked by Neo Skills Secret Guard.",systemMessage:"\uD83D\uDD12 Security Alert: Sensitive data access blocked."})),process.exit(0);process.stdout.write(JSON.stringify({decision:"allow"})),process.exit(0)}catch(g){console.error(`[Fail-safe] Secret Guard Internal Error: ${g?.message||g}`),process.exit(2)}}U();