understand-anything/
├── understand-anything-plugin/     # 主要 Plugin
│   ├── skills/                     # Skill 定義（8 個指令）
│   │   ├── understand/             # /understand — 主分析
│   │   ├── understand-dashboard/   # /understand-dashboard
│   │   ├── understand-chat/        # /understand-chat
│   │   ├── understand-explain/     # /understand-explain
│   │   ├── understand-onboard/     # /understand-onboard
│   │   ├── understand-diff/        # /understand-diff
│   │   ├── understand-domain/      # /understand-domain
│   │   └── understand-knowledge/   # /understand-knowledge
│   ├── agents/                     # Agent Prompt 定義
│   │   ├── project-scanner.md
│   │   ├── file-analyzer.md
│   │   ├── architecture-analyzer.md
│   │   ├── tour-builder.md
│   │   ├── graph-reviewer.md
│   │   └── knowledge-graph-guide.md
│   └── packages/
│       ├── core/                   # TypeScript 核心庫（Zod Schema, 持久化）
│       │   ├── scan-project.mjs    # 確定性檔案列舉（v2.7.5 新增）
│       │   ├── extract-import-map.mjs  # importMap 解析器（v2.7.5 新增）
│       │   └── compute-batches.mjs # Louvain 分群計算（v2.7.5 新增）
│       └── dashboard/              # React Dashboard（Vite）
├── .claude-plugin/                 # Claude Code 自動發現
├── .copilot-plugin/                # VS Code Copilot 自動發現
├── .cursor-plugin/                 # Cursor 自動發現
├── homepage/                       # Astro 官方首頁
├── docs/superpowers/               # 設計文件與實作計畫
├── scripts/                        # 工具腳本
├── tests/                          # 整合測試（193 vitest + 69 Python）
│   └── skill/understand/           # 主分析技能測試
├── CLAUDE.md                       # 架構指引
├── CONTRIBUTING.md                 # 貢獻指南
└── README.md                       # 主文件

- 定位 Plugin 目錄
- 驗證 Git commit hash
- 讀取 README 與 Manifest

- 偵測專案名稱、語言、框架
- 委派內建腳本 scan-project.mjs 進行確定性檔案列舉（v2.7.5 起）
  → 取代原先由 LLM 撰寫的掃描器，速度提升 3-5 倍
- extract-import-map.mjs 預先解析 importMap
  → 支援 10+ 語言解析器，含 Go/TS/PHP/Python Monorepo 多根解析
- 輸出：scan-results.json + importMap

- 以 Louvain 社群偵測演算法取代固定計數式分批
- 根據 importMap 的模組耦合度進行語意分群
- 同一社群的檔案分在同一批次，減少跨批次邊遺漏
- 輸出：batch-plan.json

- 最多 3 個並行（v2.7.5 起由 5 調整為 3）
- 使用多段式輸出協議（Multi-part Output）：分段產出 JSON，降低截斷風險
- neighborMap：跨批次邊發射，確保社群邊界的依賴關係不遺漏
- Anti-fusion strict naming：嚴格命名防止節點融合
- 為每個節點產生 LLM 摘要
- 輸出：batch-<N>.json

- 識別架構層級：API / Service / Data / UI / Utility
- 為每個層級分配色碼
- 輸出：layers.json

- 依拓撲順序產生學習路徑
- 解釋元件間的連結
- 輸出：tour.json

- 驗證參考完整性
- 移除孤兒節點
- 去重
- 輸出：最終 knowledge-graph.json

.understand-anything/
├── intermediate/           # 中間產物（不需提交 Git）
│   ├── scan-results.json   # Phase 1 → Phase 1.5
│   ├── import-map.json     # Phase 1 extract-import-map.mjs 輸出
│   ├── batch-plan.json     # Phase 1.5 compute-batches.mjs 輸出
│   ├── batch-1.json        # Phase 2 輸出
│   ├── batch-2.json
│   ├── layers.json         # Phase 3 → Phase 4
│   └── tour.json           # Phase 4 → Phase 5
├── knowledge-graph.json    # 最終產物（提交 Git）
└── diff-overlay.json       # 差異分析（不需提交 Git）

{
  "id": "file:src/auth/login.ts",
  "type": "file",
  "name": "login.ts",
  "filePath": "src/auth/login.ts",
  "lineRange": [1, 150],
  "summary": "處理使用者登入邏輯，包含 JWT Token 驗證與 Session 管理",
  "tags": ["auth", "login", "jwt", "session"],
  "complexity": "moderate",
  "languageNotes": "使用 async/await 模式與 Express middleware"
}

{
  "source": "file:src/auth/login.ts",
  "target": "file:src/models/user.ts",
  "type": "imports",
  "direction": "forward",
  "description": "匯入 User Model 以進行身分驗證查詢",
  "weight": 0.9
}

{
  "id": "layer:api",
  "name": "API Layer",
  "description": "HTTP 請求處理與路由",
  "nodeIds": ["file:src/routes/auth.ts", "file:src/routes/user.ts"]
}

{
  "order": 1,
  "title": "應用程式入口",
  "description": "從 index.ts 開始理解伺服器的啟動流程",
  "nodeIds": ["file:src/index.ts"],
  "languageLesson": "此專案使用 Express 框架的 middleware 模式..."
}

# 分析完成後開啟 Dashboard
/understand-dashboard

# 產生繁體中文內容
/understand --language zh-TW

# 產生日文內容
/understand --language ja

# 使用 winget 安裝 Node.js v24
winget install -e --id OpenJS.NodeJS --version 24.0.0

# 或使用 nvm-windows
nvm install 24
nvm use 24

# 驗證
node --version   # 應顯示 v24.x.x

# 使用 npm 安裝 pnpm
npm install -g pnpm

# 或使用 Corepack（Node 16+ 內建）
corepack enable
corepack prepare pnpm@latest --activate

# 驗證
pnpm --version

# 在 Claude Code 中執行
/plugin marketplace add Lum1104/Understand-Anything
/plugin install understand-anything

# 複製 Repo
git clone https://github.com/Lum1104/Understand-Anything.git

# 在 VS Code 中開啟（v1.108+ 自動發現 .copilot-plugin/plugin.json）
code Understand-Anything

# 執行安裝腳本（支援 Codex / Copilot / Gemini CLI 等平台）
iwr -useb https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.ps1 | iex

codex, opencode, openclaw, antigravity, gemini, pi, vibe, vscode, hermes, cline, kimi

# 更新
./install.sh --update

# 解除安裝
./install.sh --uninstall <platform>

# 在支援的 AI 平台中執行
/understand --help

# 使用 nvm（推薦）
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash
source ~/.bashrc
nvm install 24
nvm use 24

# 驗證
node --version

# Corepack（推薦）
corepack enable
corepack prepare pnpm@latest --activate

# 或 npm 安裝
npm install -g pnpm

# 一行安裝
curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash

# 指定平台（跳過互動提示）
curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash -s codex

# 使用 Homebrew
brew install node@24

# 或 nvm
nvm install 24
nvm use 24

# Homebrew
brew install pnpm

# 或 Corepack
corepack enable
corepack prepare pnpm@latest --activate

# 一行安裝（與 Linux 相同）
curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash

Error: This project requires Node.js >= 22

# 檢查版本
node --version

# 升級至 v24
nvm install 24
nvm use 24

Error: pnpm: command not found

# 啟用 Corepack
corepack enable

# 或直接安裝
npm install -g pnpm

Error: EPERM: operation not permitted, symlink

# 以系統管理員身份執行 PowerShell
# 或啟用 Developer Mode：
# 設定 → 更新與安全性 → 開發人員 → 啟用開發人員模式

# 使用 shallow clone
git clone --depth 1 https://github.com/Lum1104/Understand-Anything.git

# 或使用 GitHub CLI
gh repo clone Lum1104/Understand-Anything -- --depth 1

# 從 Plugin Marketplace 新增
/plugin marketplace add Lum1104/Understand-Anything

# 安裝
/plugin install understand-anything

# 複製 Repo
git clone https://github.com/Lum1104/Understand-Anything.git ~/.understand-anything/repo

# Claude Code 會自動偵測 .claude-plugin/plugin.json

{
  "name": "understand-anything",
  "version": "2.7.3",
  "description": "Turn any codebase into an interactive knowledge graph",
  "skills": [
    "understand",
    "understand-dashboard",
    "understand-chat",
    "understand-explain",
    "understand-onboard",
    "understand-diff",
    "understand-domain",
    "understand-knowledge"
  ],
  "agents": [
    "project-scanner",
    "file-analyzer",
    "architecture-analyzer",
    "tour-builder",
    "graph-reviewer"
  ]
}

傳統方式：送入 50 個檔案原始碼 → ~150,000 tokens
Graph 方式：送入 50 個節點摘要 + Edge → ~5,000 tokens
節省比例：~96%

# Step 1: 分析專案（繁體中文）
/understand --language zh-TW

# Step 2: 開啟 Dashboard 瀏覽
/understand-dashboard

# Step 3: 與圖譜對話
/understand-chat 這個專案的核心架構是什麼？

# Step 4: 深入特定模組
/understand-explain src/auth/

# Step 5: 產生新人指南
/understand-onboard

# Step 1: 修改程式碼
# ... 修改 src/payment/checkout.ts ...

# Step 2: 分析影響範圍
/understand-diff

# Step 3: 詢問風險
/understand-chat 我修改了 checkout.ts，哪些模組可能受影響？

# Step 1: 提取業務領域知識
/understand-domain

# Step 2: 在 Dashboard 中切換到 Domain View
/understand-dashboard

# Step 3: 查詢特定業務流程
/understand-chat 訂單建立的完整流程有哪些步驟？

# 分析 Karpathy-pattern Wiki
/understand-knowledge ~/docs/team-wiki

# 開啟知識圖譜
/understand-dashboard

# Step 1: 分析 Legacy 系統
/understand --language zh-TW

# Step 2: 找出所有 Dead Code
/understand-chat 哪些函式沒有被任何其他模組呼叫？

# Step 3: 找出 Circular Dependency
/understand-chat 是否存在循環相依？列出所有循環路徑

# Step 4: 產生架構文件
/understand-onboard

# 方式 1：複製 Repo 到專案目錄
git clone https://github.com/Lum1104/Understand-Anything.git

# 在 VS Code 中開啟 — 自動發現 Plugin
code Understand-Anything

# 方式 2：安裝為個人 Skill（所有專案可用）
curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash -s vscode

copilot plugin install Lum1104/Understand-Anything:understand-anything-plugin

# 分析目前工作區
/understand

# 開啟 Dashboard
/understand-dashboard

# 詢問問題
/understand-chat 這個 API 的資料流向是什麼？

# 複製 Repo 到專案目錄
git clone https://github.com/Lum1104/Understand-Anything.git

# 在 Cursor 中開啟 — 自動發現
cursor Understand-Anything

# 安裝
curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash -s codex

# 使用
/understand
/understand-dashboard

# 安裝
curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash -s gemini

# 使用（與其他平台相同的指令集）
/understand --language zh-TW

// mcp-understand-anything-server.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { readFileSync } from "fs";
import { z } from "zod";

const server = new McpServer({
  name: "understand-anything",
  version: "1.0.0",
});

// 載入知識圖譜
const graphPath = ".understand-anything/knowledge-graph.json";

// Tool: 搜尋節點
server.tool(
  "search-graph",
  "搜尋知識圖譜中的節點",
  { query: z.string().describe("搜尋關鍵字") },
  async ({ query }) => {
    const graph = JSON.parse(readFileSync(graphPath, "utf-8"));
    const results = graph.nodes.filter(
      (n: any) =>
        n.name.includes(query) ||
        n.summary?.includes(query) ||
        n.tags?.some((t: string) => t.includes(query))
    );
    return {
      content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
    };
  }
);

// Tool: 查詢節點關係
server.tool(
  "get-relationships",
  "查詢特定節點的所有關係",
  { nodeId: z.string().describe("節點 ID") },
  async ({ nodeId }) => {
    const graph = JSON.parse(readFileSync(graphPath, "utf-8"));
    const edges = graph.edges.filter(
      (e: any) => e.source === nodeId || e.target === nodeId
    );
    return {
      content: [{ type: "text", text: JSON.stringify(edges, null, 2) }],
    };
  }
);

// Tool: 取得架構層級
server.tool(
  "get-layers",
  "取得專案架構層級",
  {},
  async () => {
    const graph = JSON.parse(readFileSync(graphPath, "utf-8"));
    return {
      content: [{ type: "text", text: JSON.stringify(graph.layers, null, 2) }],
    };
  }
);

// 啟動
const transport = new StdioServerTransport();
await server.connect(transport);

{
  "mcp": {
    "servers": {
      "understand-anything": {
        "command": "npx",
        "args": ["tsx", "mcp-understand-anything-server.ts"],
        "cwd": "${workspaceFolder}"
      }
    }
  }
}

# 先分析後端核心
/understand src/main/java --language zh-TW

# 再分析前端
/understand src/frontend --language zh-TW

# 最後分析配置
/understand src/main/resources --language zh-TW

# 全專案分析（中大型專案約 5-15 分鐘）
/understand --language zh-TW

{
  "project": {
    "name": "enterprise-platform",
    "languages": ["java", "typescript", "vue", "sql"],
    "frameworks": ["spring-boot", "vue3", "mybatis", "kafka"],
    "description": "企業級共用平台，包含使用者管理、權限控管、報表系統"
  },
  "nodes": [
    {
      "id": "class:src/main/java/com/corp/controller/UserController.java:UserController",
      "type": "class",
      "name": "UserController",
      "summary": "使用者管理 REST API，提供 CRUD 操作與搜尋功能",
      "tags": ["api", "controller", "user"],
      "complexity": "moderate"
    }
  ]
}

# 詢問整體架構
/understand-chat 這個系統的整體架構是什麼？有哪些主要模組？

# 理解資料流向
/understand-chat 使用者登入的完整資料流向是什麼？從前端到資料庫

# 理解業務領域
/understand-domain

/understand-chat UserController 依賴哪些 Service？這些 Service 又依賴哪些 Repository？

UserController
  → imports UserService
    → imports UserRepository
      → reads_from USER 表
    → imports RoleService
      → imports RoleRepository
        → reads_from ROLE 表
  → imports AuthService
    → calls SSO Gateway

/understand-dashboard

# 查詢所有 API Endpoint
/understand-chat 列出所有 REST API Endpoint，包含 HTTP 方法和路徑

# 追蹤特定 API 的完整流程
/understand-chat POST /api/orders 從接收請求到回傳回應的完整流程

# 找出所有跨域 API 呼叫
/understand-chat 哪些 API 會呼叫外部服務或其他微服務？

# 查詢所有批次任務
/understand-chat 列出所有 Spring Batch Job，包含 Step 和 Reader/Writer

# 追蹤批次資料流
/understand-chat DailySettlementJob 的資料從哪裡來，寫到哪裡去？

# 分析批次相依
/understand-chat 哪些 Batch Job 之間有先後順序？

# 查詢所有 Kafka/MQ Producer 和 Consumer
/understand-chat 列出所有 Kafka Producer 和 Consumer，以及它們使用的 Topic

# 追蹤訊息流向
/understand-chat order-created 事件從 Producer 到 Consumer 的完整路徑

# 分析訊息依賴
/understand-chat 如果 payment-service 的 Kafka Consumer 停止運作，哪些業務流程會受影響？

# 查詢所有資料表關係
/understand-chat 列出所有資料表及其外鍵關係

# 追蹤資料存取
/understand-chat 哪些 Service 會讀寫 USER 表？

# 分析 Schema 變更影響
/understand-chat 如果我在 ORDER 表新增一個欄位，哪些 Repository 和 DTO 需要修改？

# Step 1: 分析現有模式
/understand-chat 專案中 Controller → Service → Repository 的標準寫法模式是什麼？

# Step 2: 請 AI 根據模式產生新功能
# 在 Claude Code / Copilot 中：
「請參考現有的 UserController 模式，建立一個 ProductController，
 包含 CRUD 和搜尋功能，使用相同的 Exception 處理方式和 Response 格式。」

# Step 3: 驗證新功能的圖譜位置
/understand
/understand-chat ProductController 是否正確地連結到 Service 和 Repository 層？

# Step 1: 分析完整專案
/understand --language zh-TW

# Step 2: 查詢 Java EE 特定元件
/understand-chat 列出所有 EJB（Session Bean, Entity Bean, Message-Driven Bean）

/understand-chat 列出所有 Servlet 和 Filter，以及它們的 URL 映射

/understand-chat 列出所有 JPA Entity 和它們的資料表映射

/understand-chat 列出所有 JNDI 資源引用

# 查詢跨模組相依
/understand-chat 產生模組間依賴矩陣，顯示每個模組依賴了哪些其他模組

# 找出高耦合模組
/understand-chat 哪些模組被最多其他模組依賴？（fan-in 最高）

# 找出外部依賴
/understand-chat 哪些模組直接呼叫外部系統（SOAP/REST/JDBC/JMS）？

# 追蹤特定方法的呼叫鏈
/understand-chat 從 OrderService.createOrder() 開始，追蹤所有呼叫路徑到 DAO 層

# 反向追蹤
/understand-chat 哪些 Controller/Servlet 最終會呼叫 UserDAO.findById()？

# 找出最深的呼叫鏈
/understand-chat 哪個業務流程的呼叫鏈最深？列出完整路徑

# 列出所有批次任務
/understand-chat 列出所有 Batch/Cron Job，包含排程時間和觸發條件

# 分析批次依賴
/understand-chat 哪些批次任務之間有資料依賴？

# 追蹤批次資料流
/understand-chat 月結批次從哪些表讀取資料，產生哪些報表，寫入哪些表？

# 分析所有 DB Schema
/understand-chat 列出所有資料表的主鍵、外鍵和索引

# 找出 Orphan Table
/understand-chat 哪些資料表沒有任何 Java Entity 或 DAO 對應？

# 找出 N+1 查詢風險
/understand-chat 哪些 Entity 的關聯載入策略是 EAGER？可能導致 N+1 問題

# 列出所有外部介面
/understand-chat 列出所有對外 API（REST/SOAP/gRPC），包含路徑和參數

# 列出所有下游呼叫
/understand-chat 列出所有呼叫外部系統的程式碼，包含目標 URL/Queue/Topic

# 產生 API 對照表
/understand-chat 產生 API Mapping 表格：Endpoint → Controller → Service → DAO → Table

# 1. 分析 Legacy Java EE 系統
/understand --language zh-TW

# 2. 產生架構概覽
/understand-onboard

# 3. 分析核心業務流程
/understand-domain

# 4. 找出 Dead Code
/understand-chat 列出所有沒有被呼叫的 public 方法

# 5. 找出 Circular Dependency
/understand-chat 是否存在循環相依？畫出所有循環路徑

# 6. 找出高風險模組
/understand-chat 哪些類別的 complexity 是 "complex"？列出前 20 個

# 7. 產生架構圖
/understand-dashboard
# → 截圖存為架構文件

# 8. 產生 Migration 計畫
/understand-chat 如果要將這個 Java EE 系統遷移到 Spring Boot 3，
最大的風險是什麼？建議的遷移順序是什麼？

# 分析與 Mainframe 的整合點
/understand-chat 列出所有與 Mainframe/CICS/IMS 互動的程式碼
/understand-chat 哪些 JCA Connector 或 MQ 通道連接到 Mainframe？
/understand-chat 這些整合點處理的業務資料有哪些？

# Step 1: 分析現有系統
/understand --language zh-TW

# Step 2: 找出所有 javax.* 引用（需遷移到 jakarta.*）
/understand-chat 列出所有使用 javax.* 套件的檔案和類別

# Step 3: 找出 Spring Security 設定
/understand-chat 列出所有 Spring Security 相關的設定類別和過濾器

# Step 4: 找出被棄用的 API
/understand-chat 列出所有使用 @Deprecated 或已棄用 Spring API 的程式碼

# Step 5: 找出自訂 Auto-Configuration
/understand-chat 列出所有 @Configuration 和 @AutoConfiguration 類別

/understand-chat 根據 Spring Boot 2 → 3 的已知變更，分析這個專案中：
1. 需要修改的檔案數量
2. javax → jakarta 的替換範圍
3. Spring Security 設定變更
4. 第三方套件相容性風險

# 找出 Java 8 特有 API 使用
/understand-chat 列出所有使用 Java 8 特有或在 Java 21 中被棄用的 API

# 找出可使用 Java 21 新特性的地方
/understand-chat 列出所有可以用 Record 取代的 POJO/DTO 類別
/understand-chat 列出所有可以用 sealed class 改寫的繼承體系
/understand-chat 列出所有可以用 pattern matching 簡化的 instanceof 檢查

# 分析模組化影響
/understand-chat 這個專案使用了哪些 internal JDK API（sun.*, com.sun.*）？

# 分析 Java EE → Jakarta EE 影響
/understand-chat 列出所有使用 javax.servlet, javax.persistence, javax.ejb 的程式碼

# 分析 EJB → CDI 遷移
/understand-chat 列出所有 @Stateless, @Stateful, @Singleton EJB，
建議如何遷移到 CDI @ApplicationScoped 或 Spring @Service

# 分析 JPA Provider 影響
/understand-chat 列出所有 JPA 特定（非標準）的 Hibernate/EclipseLink 用法

# Step 1: 建立升級前的 Graph
/understand --language zh-TW
# 保存為 baseline: cp knowledge-graph.json knowledge-graph-before.json

# Step 2: 請 AI 根據 Graph 分析執行升級
# 在 Claude Code / Copilot 中：
「根據 Knowledge Graph 的分析，將所有 javax.servlet 替換為 jakarta.servlet。
只修改 Graph 中標記為使用 javax.* 的檔案。」

# Step 3: 重建 Graph
/understand

# Step 4: 比對差異
/understand-diff

# Step 5: 驗證升級完整性
/understand-chat 升級後是否還有遺漏的 javax.* 引用？

{
  "version": "1.0.0",
  "kind": "codebase",
  "project": {
    "name": "enterprise-platform",
    "languages": ["java", "typescript"],
    "frameworks": ["spring-boot", "vue3"],
    "description": "企業級共用平台",
    "analyzedAt": "2026-05-25T10:30:00Z",
    "gitCommitHash": "a1b2c3d4e5f6..."
  },
  "nodes": [ ... ],
  "edges": [ ... ],
  "layers": [ ... ],
  "tour": [ ... ]
}

{
  "id": "function:src/services/payment.ts:processPayment",
  "type": "function",
  "name": "processPayment",
  "filePath": "src/services/payment.ts",
  "lineRange": [45, 89],
  "summary": "處理付款請求，驗證信用卡並提交到支付閘道",
  "tags": ["payment", "gateway", "async"],
  "complexity": "complex",
  "languageNotes": "使用 async/await 搭配 try-catch 進行錯誤處理"
}

{
  "id": "domain:payment",
  "type": "domain",
  "name": "支付領域",
  "summary": "處理所有支付相關業務，包含信用卡、銀行轉帳、電子錢包",
  "tags": ["payment", "financial"],
  "domainMeta": {
    "flows": ["checkout-flow", "refund-flow"],
    "stakeholders": ["payment-team", "risk-team"]
  }
}

{
  "id": "article:wiki/architecture-decisions.md",
  "type": "article",
  "name": "架構決策紀錄",
  "summary": "記錄所有重要的架構決策，包含決策背景、選項分析和結論",
  "tags": ["adr", "architecture"],
  "knowledgeMeta": {
    "entities": ["microservices", "event-sourcing", "cqrs"],
    "claims": ["CQRS 提升讀取效能 10 倍"],
    "sources": ["Martin Fowler", "Vaughn Vernon"]
  }
}

{
  "source": "file:src/controllers/order.ts",
  "target": "file:src/services/order.ts",
  "type": "imports",
  "direction": "forward",
  "description": "匯入 OrderService 以處理訂單業務邏輯",
  "weight": 0.9
}

結構性 (5): imports, exports, contains, inherits, implements
行為性 (4): calls, subscribes, publishes, middleware
資料流 (4): reads_from, writes_to, transforms, validates
相依性 (3): depends_on, tested_by, configures
通用   (2): related, similar_to
基礎設施(4): deploys, serves, provisions, triggers
Schema (4): migrates, documents, routes, defines_schema
領域   (3): contains_flow, flow_step, cross_domain
知識   (6): cites, contradicts, builds_on, exemplifies, categorized_under, authored_by

"function_def" → "function"
"method"       → "function"
"interface"    → "class"
"type_def"     → "concept"
"note"         → "article"
"page"         → "article"
"person"       → "entity"
"category"     → "topic"
"assertion"    → "claim"
"reference"    → "source"

"depends_on"     → "depends_on"
"references"     → "cites"
"conflicts_with" → "contradicts"
"extends"        → "builds_on"
"example_of"     → "exemplifies"
"belongs_to"     → "categorized_under"
"written_by"     → "authored_by"

import { readFileSync } from "fs";

const graph = JSON.parse(
  readFileSync(".understand-anything/knowledge-graph.json", "utf-8")
);

// 查詢所有 complex 節點
const complexNodes = graph.nodes.filter((n) => n.complexity === "complex");
console.log(`高複雜度模組: ${complexNodes.length}`);
complexNodes.forEach((n) => console.log(`  - ${n.name}: ${n.summary}`));

// 查詢所有 circular dependency
const importEdges = graph.edges.filter((e) => e.type === "imports");
// ... 使用 DFS 檢測環路 ...

// 統計各層節點數
const layerStats = graph.layers.map((l) => ({
  name: l.name,
  count: l.nodeIds.length,
}));
console.table(layerStats);

import json
from collections import Counter

with open(".understand-anything/knowledge-graph.json") as f:
    graph = json.load(f)

# 節點類型統計
type_counts = Counter(n["type"] for n in graph["nodes"])
print("節點類型分佈:")
for t, c in type_counts.most_common():
    print(f"  {t}: {c}")

# Edge 類型統計
edge_counts = Counter(e["type"] for e in graph["edges"])
print("\nEdge 類型分佈:")
for t, c in edge_counts.most_common():
    print(f"  {t}: {c}")

# Fan-in 分析（被依賴最多的模組）
from collections import defaultdict
fan_in = defaultdict(int)
for edge in graph["edges"]:
    fan_in[edge["target"]] += 1
top_deps = sorted(fan_in.items(), key=lambda x: x[1], reverse=True)[:10]
print("\n被依賴最多的模組（Top 10）:")
for node_id, count in top_deps:
    print(f"  {node_id}: {count} 個依賴者")

# 只分析核心模組（大幅減少 Token）
/understand src/core

# 分析前端
/understand src/frontend

# 分析特定微服務
/understand services/payment-service

# 首次分析（全量）
/understand

# 後續只分析變更檔案（增量）
/understand
# 系統自動偵測 git commit hash 變更，僅重新分析修改過的檔案

# 安裝 post-commit hook（每次 commit 自動增量更新）
/understand --auto-update

# 一個人分析，團隊共享
/understand

# 提交 Graph 到 Git
git add .understand-anything/knowledge-graph.json
git commit -m "chore: update knowledge graph"
git push

# 團隊成員直接使用，無需重跑 Pipeline
/understand-dashboard

# Git LFS 設定
git lfs install
git lfs track ".understand-anything/*.json"
git add .gitattributes .understand-anything/

# Understand-Anything — 不需提交的檔案
.understand-anything/intermediate/
.understand-anything/diff-overlay.json

# 在 PR Review 前執行
/understand-diff
# → 檢查變更是否影響安全相關模組（auth, crypto, session）

# 定期掃描
/understand-chat 列出所有直接處理使用者輸入的函式（可能的注入風險點）
/understand-chat 列出所有包含加密/雜湊操作的模組
/understand-chat 列出所有外部 API 呼叫點（可能的 SSRF 風險）

# Understand-Anything 安全設定
.understand-anything/intermediate/    # 中間產物不提交
.understand-anything/diff-overlay.json # 差異覆蓋不提交

# 確保敏感檔案不被分析
*.pem
*.key
*.env.local
**/secrets/**

# AI Tool 使用規範 — Understand-Anything

## 1. 使用範圍
- 僅限內部開發專案使用
- 禁止分析客戶專案原始碼（除非合約允許）

## 2. 存取控制
- Graph 檔案視為「內部機密」等級
- 僅開發團隊成員可存取

## 3. 資料處理
- 分析前確認原始碼不含硬編碼密碼
- 定期審查 Graph 摘要是否洩露敏感資訊

## 4. Token 管理
- 每團隊每月 Token 預算上限：___
- 超額需團隊主管核准

## 5. 版本控制
- Graph 提交至 Git，納入 Code Review 流程
- 大型 Graph (>10 MB) 使用 Git LFS

main
├── develop
│   ├── feature/new-payment
│   │   └── .understand-anything/ (增量更新)
│   └── feature/user-profile
│       └── .understand-anything/ (增量更新)
└── release/v2.0
    └── .understand-anything/ (全量重建)

# 安裝 post-commit hook（自動增量更新 Graph）
/understand --auto-update

#!/bin/sh
# .git/hooks/post-commit
# Understand-Anything 增量更新

# 只在 develop 和 main 分支觸發
branch=$(git rev-parse --abbrev-ref HEAD)
if [ "$branch" = "develop" ] || [ "$branch" = "main" ]; then
  echo "🔄 Updating knowledge graph..."
  # 觸發增量分析（由 AI 平台在背景執行）
fi

# .github/workflows/understand-anything.yml
name: Update Knowledge Graph

on:
  push:
    branches: [main, develop]
  schedule:
    - cron: '0 6 * * 1'  # 每週一早上 6 點全量重建

jobs:
  update-graph:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 24

      - name: Install pnpm
        run: corepack enable && corepack prepare pnpm@latest --activate

      - name: Install Understand-Anything
        run: |
          curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash -s codex

      - name: Run Analysis
        run: /understand --language zh-TW

      - name: Commit Graph
        run: |
          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add .understand-anything/knowledge-graph.json
          git diff --cached --quiet || git commit -m "chore: update knowledge graph [skip ci]"
          git push

# .github/workflows/pr-impact-analysis.yml
name: PR Impact Analysis

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  impact-analysis:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run Diff Analysis
        run: /understand-diff

      - name: Comment on PR
        uses: actions/github-script@v7
        with:
          script: |
            // 讀取 diff-overlay.json 並產生影響摘要
            const fs = require('fs');
            const overlay = JSON.parse(
              fs.readFileSync('.understand-anything/diff-overlay.json', 'utf-8')
            );
            const body = `## 🔍 Knowledge Graph 影響分析\n\n` +
              `受影響的節點: ${overlay.affectedNodes?.length || 0}\n` +
              `受影響的邊: ${overlay.affectedEdges?.length || 0}\n`;
            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: body
            });

# 1. 架構師建立 Graph
/understand --language zh-TW

# 2. 產生 Onboarding 文件
/understand-onboard
# → 分享給新進成員

# 3. 提交至 Git
git add .understand-anything/
git commit -m "docs: update knowledge graph"
git push

# 4. 新進成員使用
git pull
/understand-dashboard
# → 從 Learn Mode 開始學習

# 分析團隊 Wiki（如 Confluence 匯出的 Markdown）
/understand-knowledge ~/docs/team-wiki

# 在 Dashboard 中瀏覽知識圖譜
/understand-dashboard

1. [ ] 確認環境需求（Node.js ≥ 22, pnpm ≥ 10）
2. [ ] 選擇 AI 平台並安裝 Plugin
3. [ ] 架構師執行首次全量分析：/understand --language zh-TW
4. [ ] 架構師審查 Knowledge Graph 品質
5. [ ] 設定 .gitignore（排除 intermediate/）
6. [ ] 提交 Graph 至 Git
7. [ ] 設定 Auto-Update Hook
8. [ ] 建立 CI/CD Pipeline（排程 + PR 觸發）
9. [ ] 產生 Onboarding 文件：/understand-onboard
10. [ ] 團隊培訓（Dashboard 操作 + CLI 指令）

每日：
- [ ] 增量更新 Graph（Auto-Update Hook 自動執行）

每週：
- [ ] 審查 Token 使用量
- [ ] 確認 Graph 是否需要全量重建

每月：
- [ ] 全量重建 Graph
- [ ] 審查 Graph 品質（架構師）
- [ ] 更新 Onboarding 文件

每季：
- [ ] 評估 Token 成本趨勢
- [ ] 評估是否需要升級 Understand-Anything 版本
- [ ] 更新團隊使用規範

project-root/
├── .understand-anything/           # Knowledge Graph 產物
│   ├── knowledge-graph.json        # ← 提交 Git
│   ├── intermediate/               # ← 不提交（.gitignore）
│   └── diff-overlay.json           # ← 不提交（.gitignore）
├── .claude-plugin/                 # Claude Code Plugin 設定
├── .copilot-plugin/                # VS Code Copilot Plugin 設定
├── .cursor-plugin/                 # Cursor Plugin 設定
├── docs/
│   ├── architecture/               # 架構文件（由 /understand-onboard 產生）
│   └── onboarding/                 # 新人引導文件
└── ...

# 團隊 Prompt 範本

## 架構查詢
/understand-chat 列出 {模組名稱} 的所有依賴和被依賴關係

## 影響分析
/understand-chat 如果修改 {檔案路徑}，哪些模組可能受影響？

## 業務流程
/understand-chat {業務流程名稱} 的完整資料流向是什麼？

## 技術債
/understand-chat 列出 complexity 為 "complex" 的前 N 個模組

## 新功能開發
/understand-chat 專案中 {模式名稱} 的標準寫法是什麼？請給範例

## API 盤點
/understand-chat 列出所有 REST API Endpoint，格式：HTTP方法 路徑 → Controller → Service

Step 1: 讀取上次分析的 gitCommitHash
Step 2: 比對當前 HEAD 的 commit hash
Step 3: 透過 git diff 找出變更的檔案
Step 4: 僅重新分析變更檔案
Step 5: 合併新節點/邊到現有 Graph
Step 6: 更新 gitCommitHash

# 清理中間產物（不影響最終 Graph）
rm -rf .understand-anything/intermediate/

# 清理差異覆蓋
rm -f .understand-anything/diff-overlay.json

# 完全重建（清除所有產物後重新分析）
rm -rf .understand-anything/
/understand --language zh-TW

# 設定 Git LFS
git lfs install
git lfs track ".understand-anything/*.json"
git add .gitattributes

#!/usr/bin/env python3
"""Knowledge Graph 健康度檢查"""
import json
import sys
from collections import Counter
from pathlib import Path

graph_path = Path(".understand-anything/knowledge-graph.json")
if not graph_path.exists():
    print("❌ Knowledge Graph 不存在")
    sys.exit(1)

graph = json.loads(graph_path.read_text())

# 基本統計
nodes = graph.get("nodes", [])
edges = graph.get("edges", [])
layers = graph.get("layers", [])

print(f"📊 Knowledge Graph 健康度報告")
print(f"{'='*50}")
print(f"節點數: {len(nodes)}")
print(f"邊數:   {len(edges)}")
print(f"層級數: {len(layers)}")
print(f"Git Hash: {graph['project'].get('gitCommitHash', 'N/A')[:8]}")
print(f"分析時間: {graph['project'].get('analyzedAt', 'N/A')}")

# 節點類型分佈
type_counts = Counter(n["type"] for n in nodes)
print(f"\n📌 節點類型分佈:")
for t, c in type_counts.most_common():
    print(f"  {t:20s}: {c}")

# 檢查孤兒節點
node_ids = {n["id"] for n in nodes}
edge_nodes = {e["source"] for e in edges} | {e["target"] for e in edges}
orphans = node_ids - edge_nodes
if orphans:
    print(f"\n⚠️ 孤兒節點: {len(orphans)}")
    for o in list(orphans)[:5]:
        print(f"  - {o}")

# 檢查斷裂邊（引用不存在的節點）
broken = [e for e in edges if e["source"] not in node_ids or e["target"] not in node_ids]
if broken:
    print(f"\n❌ 斷裂邊: {len(broken)}")
else:
    print(f"\n✅ 無斷裂邊")

# 複雜度統計
complexity = Counter(n.get("complexity", "unknown") for n in nodes)
print(f"\n📈 複雜度分佈:")
for c, count in complexity.most_common():
    print(f"  {c:20s}: {count}")

# 缺失摘要
no_summary = sum(1 for n in nodes if not n.get("summary"))
if no_summary > 0:
    print(f"\n⚠️ 缺少摘要的節點: {no_summary}")
else:
    print(f"\n✅ 所有節點都有摘要")

# 團隊 Token 預算範本

## 月度預算
- 首次全量分析（1000 檔案專案）: ~2.5M tokens
- 日常增量更新（每日）: ~125K tokens × 20 天 = ~2.5M tokens
- 手動查詢（/understand-chat）: ~500K tokens
- **月度總計**: ~5.5M tokens

## 預算超額處理
1. 暫停非必要的手動查詢
2. 降低 CI/CD 排程頻率
3. 限定分析範圍到關鍵模組

Error: Understand-Anything requires Node.js >= 22

# 使用 nvm 安裝 Node.js 22+
nvm install 22
nvm use 22
node -v  # 確認 v22.x.x

Error: pnpm >= 10 is required

corepack enable
corepack prepare pnpm@latest --activate
pnpm -v  # 確認 v10.x.x

Error: Failed to install plugin

Error: ENAMETOOLONG

# 啟用 Windows 長路徑支援
git config --system core.longpaths true

# 限定範圍
/understand src/

# 確認 .gitignore 排除了不需要的目錄
cat .gitignore
# 應包含：node_modules, vendor, dist, build, .git

Warning: Failed to parse file: src/legacy/old-code.js

Warning: LLM output truncated, retrying with smaller batch...

# 檢查 .gitignore
cat .gitignore

# 確認分析的檔案清單
/understand-chat 本次分析了多少檔案？有哪些被排除了？

# 檢查 intermediate 目錄是否有錯誤紀錄
ls .understand-anything/intermediate/

Error: Port 3000 already in use

# 找出佔用 port 的程序
# macOS/Linux
lsof -i :3000
# Windows
netstat -ano | findstr :3000

# 終止佔用程序，或讓 Dashboard 自動使用其他 port

# 確認 Graph 存在
ls -la .understand-anything/knowledge-graph.json

# 驗證 JSON 格式
cat .understand-anything/knowledge-graph.json | python -m json.tool > /dev/null

# 使用 Chrome/Edge/Firefox 最新版本

# 確認 plugin 已安裝
ls .claude-plugin/

# 重新安裝
npx understand-anything install claude-code

# 重啟 Claude Code

# 確認使用增量更新
/understand-chat 上次分析的 git hash 是什麼？

# 限定範圍
/understand src/main

# 使用團隊共享 Graph（避免重複分析）
git pull  # 取得他人已建構的 Graph

# 方法 1：每個 Package 獨立分析
/understand packages/common
/understand packages/frontend
/understand packages/backend
/understand packages/shared

# 方法 2：分析特定業務領域
/understand-domain packages/

# 檢查摘要品質
/understand-chat 列出所有 summary 為空或少於 10 個字的節點

# 重新產生特定模組的摘要
/understand src/services/payment.ts

# 檢查是否有重要的依賴關係缺失
/understand-chat 比較 import-resolver 找到的 import 邊與 file-analyzer 的結果，是否有遺漏？

# 檢查架構層歸屬是否正確
/understand-chat 列出每層的節點，是否有明顯歸類錯誤？

# Graph JSON 合併衝突時（通常發生在多人同時更新）
# 建議：接受最新的版本，然後重新執行增量分析

git checkout --theirs .understand-anything/knowledge-graph.json
/understand  # 重新增量分析以整合自己的變更

# 在重要里程碑標記 Graph 版本
git tag graph-v1.0 -m "Initial knowledge graph for v1.0 release"
git tag graph-v2.0 -m "Updated graph for v2.0 architecture change"

# 分析嵌入式韌體
/understand firmware/src --language zh-TW

# 分析 IoT Gateway
/understand iot-gateway/

# 分析 SCADA/HMI
/understand scada-ui/

# 分析保險核心系統
/understand insurance-core/

# 業務領域分析
/understand-domain insurance-core/
# → 保單管理、理賠、精算、再保

# 分析微服務邊界
/understand-chat 列出所有跨服務呼叫（REST/gRPC/MQ），按呼叫頻率排序

# 偵測微服務反模式
/understand-chat 是否有服務直接存取其他服務的資料庫？（Shared Database Anti-pattern）
/understand-chat 是否有過長的同步呼叫鏈？（Distributed Monolith）

# API 端點盤點
/understand-chat 列出所有 REST API Endpoint，格式：HTTP方法 路徑 → Controller → Service → Repository

# API 版本管理
/understand-chat 列出所有 /api/v1 和 /api/v2 的端點差異

# Step 1: 理解現有架構
/understand legacy-system/

# Step 2: 識別模組化邊界
/understand-domain legacy-system/

# Step 3: 評估技術債
/understand-chat 列出所有 complexity 為 "complex" 的模組，並建議現代化優先順序

# Step 4: 產生遷移計畫
/understand-chat 根據依賴關係，建議將哪些模組先行拆解為微服務？

# 查詢與決策相關的模組
/understand-chat 專案中所有與「快取」相關的模組，它們如何互動？

# 影響分析
/understand-chat 如果從 Redis 切換到 Hazelcast，哪些模組需要修改？

# 記錄決策
/understand-knowledge docs/adr/
# → 將 ADR 文件整合到知識圖譜中

/understand-chat

以架構師的角度，回答以下問題：
1. 這個專案的整體架構是什麼模式？（Monolith / Microservices / Modular Monolith）
2. 核心業務領域有哪些？
3. 資料流是如何從前端到資料庫的？
4. 有哪些跨模組的共用元件？
5. 潛在的架構風險有哪些？

/understand-diff

請根據 Knowledge Graph 的影響分析，回答：
1. 本次 PR 變更了哪些模組？
2. 有哪些下游模組可能受影響？
3. 是否有潛在的破壞性變更？
4. 測試覆蓋是否足夠？（檢查 tested_by 邊）
5. 是否符合專案的架構規範？

/understand-chat

從資安角度分析這個專案：
1. 列出所有處理使用者輸入的進入點（Controller, API Endpoint）
2. 這些進入點的輸入驗證機制是什麼？
3. 是否有 SQL Injection / XSS / CSRF 的風險點？
4. 認證與授權機制是如何實作的？
5. 敏感資料（密碼、Token）是否有妥善保護？

/understand-chat

從效能角度分析：
1. 列出所有資料庫查詢點，是否有 N+1 問題？
2. 有哪些模組使用了快取？快取策略是什麼？
3. 有哪些同步的外部 API 呼叫可能導致延遲？
4. 有哪些複雜度為 "complex" 的函式可能是效能瓶頸？

@workspace /understand-explain src/services/payment.ts

這個支付模組的完整依賴鏈是什麼？
從 Controller 到 Repository 的呼叫路徑？

@workspace /understand-chat

根據專案的 Repository Pattern 慣例，幫我產生一個新的 OrderRepository：
1. 參考現有的 UserRepository 和 PaymentRepository 的寫法
2. 包含 CRUD 操作
3. 符合專案的命名慣例和錯誤處理模式

@codebase

根據 Knowledge Graph，這個專案使用了哪些 Design Pattern？
每個 Pattern 在哪些模組中被使用？
請以表格形式列出。

@codebase

我要重構 src/services/order.ts：
1. 查看 Graph 中這個模組的所有依賴者（fan-in）
2. 列出所有會受影響的模組
3. 建議重構步驟（由內到外）
4. 產生重構後的程式碼

[角色] 以 {角色} 的身份
[任務] 請分析 {分析目標}
[格式] 以 {表格/列表/Mermaid} 格式呈現
[範圍] 專注於 {特定模組/層級}
[約束] 注意 {安全/效能/相容性} 面向

以資深 Java 架構師的身份，分析 src/services/ 目錄下的所有 Service 類別：
1. 每個 Service 的職責是什麼？（Single Responsibility 檢查）
2. Service 之間的依賴關係圖（Mermaid 格式）
3. 是否有 Circular Dependency？
4. 哪些 Service 違反了 SOLID 原則？
5. 以表格形式列出改善建議

請根據 Knowledge Graph 的資訊回答，不要猜測。

# Step 1: 理解現有架構
/understand --language zh-TW

# Step 2: 識別瓶頸
/understand-chat 列出 fan-in 最高的 10 個模組（被依賴最多 = 變更風險最高）

# Step 3: 評估拆分方案
/understand-chat 如果要將 UserService 拆分為獨立微服務，需要切斷哪些依賴？

# Step 4: 產出架構決策
/understand-chat 根據以上分析，產出一份 ADR（Architecture Decision Record）

# Step 1: 識別目標
/understand-chat 列出 complexity 為 "complex" 且行數 > 200 的函式

# Step 2: 影響分析
/understand-chat processPayment 函式被哪些模組呼叫？
/understand-chat 如果拆分 processPayment 為多個小函式，哪些呼叫點需要修改？

# Step 3: 執行重構
# （在 AI Agent 中執行實際重構）

# Step 4: 驗證
/understand-diff

# Step 1: 查詢測試覆蓋
/understand-chat 列出所有沒有 tested_by 邊的模組（未被測試的模組）

# Step 2: 優先排序
/understand-chat 根據 complexity 和 fan-in，哪些未測試模組風險最高？

# Step 3: 產生測試
/understand-chat 參考專案現有測試的寫法，為 OrderService 產生完整的單元測試

# Step 4: 驗證覆蓋
/understand  # 重新分析，更新 tested_by 邊

# Step 1: 產生架構文件
/understand-onboard

# Step 2: 產生 API 文件
/understand-chat 列出所有 REST API Endpoint，產生 OpenAPI 格式文件

# Step 3: 產生模組說明
/understand-chat 為 src/services/ 下的每個 Service 產生 README.md

# Step 4: 產生資料流文件
/understand-chat 繪製 Mermaid 流程圖：使用者下單 → 付款 → 出貨 的完整資料流

# Step 1: 識別攻擊面
/understand-chat 列出所有外部進入點（API Endpoint, WebSocket, MQ Consumer）

# Step 2: 追蹤資料流
/understand-chat 使用者輸入從 Controller 到 Repository 的完整路徑上，經過了哪些驗證？

# Step 3: 識別風險
/understand-chat 哪些模組直接使用了字串拼接的 SQL？（SQL Injection 風險）
/understand-chat 哪些模組直接將使用者輸入渲染到 HTML？（XSS 風險）

# Step 4: 依賴分析
/understand-chat 列出所有第三方依賴（imports），有哪些已知的安全漏洞？

專案：企業級共用平台
技術棧：
  前端：Vue 3 + TypeScript + Vite
  後端：Spring Boot 3.x + Java 17
  資料庫：Oracle 19c
  快取：Redis 7
  訊息佇列：Apache Kafka + IBM MQ
  批次作業：Spring Batch
  認證：SSO（SAML 2.0 + OAuth 2.0）
  API 閘道：Spring Cloud Gateway
  部署：Kubernetes + Helm

規模：
  前端元件：300+
  後端 Service：50+
  API Endpoint：200+
  Batch Job：30+
  資料表：500+
  總程式碼行數：80 萬行
  開發人員：60 人

# 1. 安裝環境
nvm install 22 && nvm use 22
corepack enable && corepack prepare pnpm@latest --activate

# 2. 安裝 Plugin（以 Claude Code 為例）
npx understand-anything install claude-code

# 前端（Vue 3）
/understand frontend/ --language zh-TW

# API Gateway
/understand api-gateway/

# 核心服務
/understand core-services/

# 批次作業
/understand batch-jobs/

# 共用元件
/understand shared-libs/

# 業務領域分析
/understand-domain .

# 產生 Onboarding 文件
/understand-onboard

# 架構師審查 Graph
/understand-dashboard

# 設定 CI/CD
# → 參考第 13 章 GitHub Actions 範例

# 團隊培訓
# → 使用 Dashboard Learn Mode 進行

/understand-chat

Vue 3 前端分析：
1. 列出所有 Composable（use*.ts），它們的依賴關係
2. Store（Pinia/Vuex）的狀態管理架構
3. Router 路由結構與權限控制
4. API 呼叫層（Axios/Fetch）的封裝方式
5. 共用元件（components/shared/）的使用頻率

/understand-chat

Spring Boot 後端分析：
1. Controller → Service → Repository 的分層架構
2. AOP 切面（Aspect）的使用場景
3. 例外處理機制（@ControllerAdvice）
4. 事務管理（@Transactional）的範圍
5. 排程任務（@Scheduled）清單

/understand-chat

資料存取分析：
1. 列出所有 Repository/DAO 及其對應的資料表
2. JPA Entity 之間的關聯（@OneToMany, @ManyToOne）
3. 原生 SQL 查詢（@Query(nativeQuery=true)）清單
4. 是否有使用 Stored Procedure？
5. 資料庫遷移工具（Flyway/Liquibase）的使用情況

/understand-chat

快取架構分析：
1. 列出所有使用 @Cacheable 的方法
2. 快取 Key 的命名策略
3. 快取失效策略（TTL, @CacheEvict）
4. 是否有分散式鎖（RedissonLock）？
5. Redis 的使用模式（Cache-Aside, Read-Through, Write-Behind）

/understand-chat

訊息架構分析：
1. 列出所有 Kafka Producer 和 Consumer
2. 列出所有 IBM MQ 的 Queue 和 Topic
3. 訊息的序列化格式（JSON, Avro, Protobuf）
4. Consumer Group 的配置
5. 死信佇列（DLQ）的處理機制

/understand-chat

批次作業分析：
1. 列出所有 Batch Job 及其排程時間
2. 每個 Job 的 Step 組成（Reader → Processor → Writer）
3. 錯誤處理機制（Skip, Retry）
4. Job 之間的依賴關係
5. 效能關鍵的 Chunk Size 設定

/understand-chat

認證授權分析：
1. SSO 整合方式（SAML 2.0 / OAuth 2.0）
2. Token 驗證流程
3. 權限模型（RBAC / ABAC）
4. Session 管理機制
5. API 金鑰管理

/understand-chat

API Gateway 分析：
1. 路由規則清單
2. 限流（Rate Limiting）設定
3. 斷路器（Circuit Breaker）配置
4. 請求/回應轉換（Filter）
5. CORS 設定