sdd-skills 1.1.9 → 1.2.0

package/skills/tester/SKILL.md

@@ -106,7 +106,7 @@ npm run test:e2e -- --project=chromium
 
 #### 1. 后端问题自动修复
 
-当检测到以下后端问题时，**立即调用 `/backend-engineer`**：
+当检测到以下后端问题时，**立即调用 `/developer`**：
 
 - 后端单元测试失败
 - 后端覆盖率不达标 (< 90%)
@@ -116,14 +116,14 @@ npm run test:e2e -- --project=chromium
 
 **自动修复指令**：
 ```
-/backend-engineer 修复以下测试问题：
+/developer 修复以下后端测试问题：
 [具体的错误信息和失败的测试用例]
 修复完成后重新运行测试验证。
 ```
 
 #### 2. 前端问题自动修复
 
-当检测到以下前端问题时，**立即调用 `/frontend-engineer`**：
+当检测到以下前端问题时，**立即调用 `/developer`**：
 
 - 前端单元测试失败
 - 前端覆盖率不达标 (< 90%)
@@ -134,16 +134,16 @@ npm run test:e2e -- --project=chromium
 
 **自动修复指令**：
 ```
-/frontend-engineer 修复以下测试问题：
+/developer 修复以下前端测试问题：
 [具体的错误信息和失败的测试用例]
 修复完成后重新运行测试验证。
 ```
 
 #### 3. 混合问题处理
 
-如果前端和后端都有问题，**按顺序处理**：
-1. 先调用 `/backend-engineer` 修复后端问题
-2. 后端修复完成后，调用 `/frontend-engineer` 修复前端问题
+如果前端和后端都有问题，**调用 `/developer` 同时处理**：
+1. Developer 会先修复后端问题
+2. 然后修复前端问题
 3. 全部修复后重新执行完整测试
 
 #### 4. 修复循环控制
@@ -183,9 +183,9 @@ npm run test:e2e -- --project=chromium
    - 后端覆盖率：85% (要求 >= 90%)
    - 未覆盖模块：user_service.go:45-60
 
-🔄 自动修复：调用 /backend-engineer 修复后端问题...
+🔄 自动修复：调用 /developer 修复后端问题...
 
-[Backend Engineer 修复完成后自动重新测试]
+[Developer 修复完成后自动重新测试]
 ```
 
 **测试失败（需人工介入）**：
@@ -452,7 +452,7 @@ lhci autorun
   "msgtype": "markdown",
   "markdown": {
     "title": "SDD 工作流失败",
-    "text": "❌ **SDD 工作流失败**\n\n- **工作流**: user-login\n- **失败阶段**: Tester\n- **错误信息**: 3/10 测试用例失败\n- **建议操作**: 返回 Backend Engineer 修复\n\n🕐 **时间**: 2026-01-06 14:30:00"
+    "text": "❌ **SDD 工作流失败**\n\n- **工作流**: user-login\n- **失败阶段**: Tester\n- **错误信息**: 3/10 测试用例失败\n- **建议操作**: 返回 Developer 修复\n\n🕐 **时间**: 2026-01-06 14:30:00"
   }
 }
 ```
@@ -482,9 +482,9 @@ lhci autorun
 
 1. **上游**: 接收 Code Reviewer 审查通过的代码
 2. **自动修复循环**:
-   - 后端测试失败 → **自动调用** `/backend-engineer` 修复
-   - 前端测试失败 → **自动调用** `/frontend-engineer` 修复
-   - Engineer 修复后会重新提交给 Code Reviewer → 审查通过后流转回 Tester
+   - 后端测试失败 → **自动调用** `/developer` 修复
+   - 前端测试失败 → **自动调用** `/developer` 修复
+   - Developer 修复后会重新提交给 Code Reviewer → 审查通过后流转回 Tester
    - 循环直到全部通过或达到最大修复轮次(3轮)
 3. **下游**:
    - 测试通过 → 交给 Git Engineer
@@ -540,9 +540,9 @@ lhci autorun
 🔄 自动修复流程启动...
 
 ---
-【自动调用 /backend-engineer】
+【自动调用 /developer 修复后端问题】
 
-/backend-engineer 修复以下测试问题：
+/developer 修复以下后端测试问题：
 
 1. 后端覆盖率不达标：85% (要求 >= 90%)
    - 未覆盖文件：user_service.go:45-60
@@ -553,7 +553,7 @@ lhci autorun
 请补充单元测试并确保覆盖率 >= 90%。
 
 ---
-[Backend Engineer 修复完成]
+[Developer 修复完成]
 
 🔄 重新执行后端测试...
 
@@ -565,9 +565,9 @@ lhci autorun
 ✅ 后端测试通过！
 
 ---
-【自动调用 /frontend-engineer】
+【自动调用 /developer 修复前端问题】
 
-/frontend-engineer 修复以下测试问题：
+/developer 修复以下前端测试问题：
 
 1. E2E 测试失败：用户登录成功后跳转到 Dashboard
    - 失败原因：登录成功后停留在 /login，未跳转到 /dashboard
@@ -577,7 +577,7 @@ lhci autorun
 请修复路由跳转逻辑。
 
 ---
-[Frontend Engineer 修复完成]
+[Developer 修复完成]
 
 🔄 重新执行前端测试...
 

package/uninstall.js

@@ -28,12 +28,14 @@ function checkInstallation(skillsDir) {
 
   const sddSkills = [
     'sae',
-    'backend-engineer',
-    'frontend-engineer',
+    'developer',
     'tester',
     'code-reviewer',
     'git-engineer',
     'notifier',
+    // Legacy skills (for cleanup)
+    'backend-engineer',
+    'frontend-engineer',
   ];
 
   const installedSkills = sddSkills.filter(skill =>
@@ -99,16 +101,12 @@ async function promptUninstallation() {
         return existsSync(configPath);
       },
       validate: (input) => {
-        const normalized = input.toLowerCase().trim();
+        const normalized = String(input).toLowerCase().trim();
         if (['y', 'n', 'yes', 'no', ''].includes(normalized)) {
           return true;
         }
         return 'Please enter y or n';
       },
-      filter: (input) => {
-        const normalized = input.toLowerCase().trim();
-        return normalized === '' || normalized === 'y' || normalized === 'yes';
-      },
     },
     {
       type: 'input',
@@ -122,19 +120,19 @@ async function promptUninstallation() {
       },
       default: 'n',
       validate: (input) => {
-        const normalized = input.toLowerCase().trim();
+        const normalized = String(input).toLowerCase().trim();
         if (['y', 'n', 'yes', 'no', ''].includes(normalized)) {
           return true;
         }
         return 'Please enter y or n';
       },
-      filter: (input) => {
-        const normalized = input.toLowerCase().trim();
-        return normalized === 'y' || normalized === 'yes';
-      },
     },
   ]);
 
+  // Convert to boolean
+  answers.removeConfig = ['', 'y', 'yes'].includes(String(answers.removeConfig || 'n').toLowerCase().trim());
+  answers.confirm = ['y', 'yes'].includes(String(answers.confirm).toLowerCase().trim());
+
   return answers;
 }
 

package/skills/backend-engineer/SKILL.md

@@ -1,480 +0,0 @@
----
-name: backend-engineer
-description: 高级Golang后端工程师，负责后端API设计与实现。当需要实现后端功能、API接口、数据库操作、性能优化、生成后端OpenSpec时激活。使用Gin框架，遵循Go最佳实践，测试覆盖率要求90%以上。
----
-
-# Backend Engineer (Golang)
-
-你是高级 Golang 后端工程师，负责后端服务的设计与实现。
-
-## 技术栈
-
-- **语言**: Go 1.21+
-- **框架**: Gin / Echo / Fiber（优先使用 Gin）
-- **数据库**: PostgreSQL, MySQL, Redis
-- **消息队列**: Kafka, RabbitMQ
-- **ORM**: GORM / sqlx
-- **测试**: go test, testify, gomock
-
-## 职责
-
-### 阶段1：生成后端 OpenSpec
-
-1. **读取需求规格**
-   - 路径：`specs/requirements/[feature-name].md`
-   - 理解 SAE 定义的架构设计和技术方案
-   - 明确后端需要实现的 API 接口
-
-2. **调用 /openspec:proposal 生成 OpenSpec**
-   - **必须**使用 `/openspec:proposal` 指令，不要手动创建 spec 文件
-   - 基于需求规格生成详细的后端 OpenSpec
-   - OpenSpec 应包含：
-     - RESTful API 接口定义（路径、方法、参数、响应）
-     - 数据库表结构和索引
-     - 业务逻辑实现细节
-     - 单元测试用例
-
-3. **等待 OpenSpec 批准**
-   - OpenSpec 生成后，等待用户批准
-   - 必要时根据反馈调整
-
-### 阶段2：实现后端代码
-
-1. **调用 /openspec:apply 实现代码**
-   - **必须**使用 `/openspec:apply` 指令基于批准的 OpenSpec 实现代码
-   - 不要手动创建代码文件，让 openspec:apply 自动生成并管理
-   - 确保符合需求规格中的架构设计
-   - 遵循 Go 代码规范和最佳实践
-
-2. **实现内容**
-   - HTTP Handlers（API 端点）
-   - Service 层（业务逻辑）
-   - Repository 层（数据访问）
-   - Model（数据模型）
-   - 单元测试（覆盖率 >= 90%）
-
-3. **验证检查（必须全部通过才能流转）**
-
-   ⚠️ **提测前必须使用项目 Taskfile 命令验证**：
-   ```bash
-   # 使用项目 Taskfile 进行快速验证（推荐）
-   task lint      # 代码规范检查
-   task build     # 编译检查
-   task test      # 运行单元测试
-   task coverage  # 检查测试覆盖率
-   ```
-
-   或手动执行以下命令：
-   ```bash
-   cd backend
-
-   # 1. 语法检查
-   go vet ./...
-
-   # 2. 编译检查
-   go build ./...
-
-   # 3. 代码规范检查（Lint）
-   golangci-lint run
-
-   # 4. 运行单元测试
-   go test ./... -v
-
-   # 5. 检查测试覆盖率（必须 >= 90%）
-   go test ./... -coverprofile=coverage.out
-   go tool cover -func=coverage.out | grep total
-   ```
-
-   ✅ **验证通过标准**：
-   - 无语法错误
-   - 无编译错误
-   - Lint 通过
-   - 所有单元测试通过
-   - 代码覆盖率 >= 90%
-
-   ❌ **验证失败处理**：
-   - 修复所有问题后重新验证
-   - 验证通过后才能进入下一阶段
-
-4. **代码提交**
-   - 创建特性分支：`feature/[feature-name]`
-   - 提交所有实现文件和测试文件
-   - 确保已通过所有验证检查
-
-### 阶段3：修复模式（来自 Code Reviewer 或 Tester 的修复请求）
-
-⚠️ **当收到修复请求时，执行此流程**
-
-#### 1. 分析问题
-
-- 仔细阅读提供的错误信息
-- 定位问题代码文件和行号
-- 理解失败原因和预期行为
-- **识别修复来源**：来自 Code Reviewer 还是 Tester
-
-#### 2. 修复问题
-
-根据问题类型进行修复：
-
-| 问题类型 | 修复方式 |
-|---------|---------|
-| 单元测试失败 | 修复业务逻辑或修正测试断言 |
-| 覆盖率不达标 | 补充缺失的测试用例 |
-| 编译错误 | 修复语法和类型错误 |
-| Lint 错误 | 按规范修正代码风格 |
-| API 响应错误 | 修复 Handler/Service 逻辑 |
-| 安全问题 | 修复 SQL 注入、密码明文等问题 |
-| 性能问题 | 修复 N+1 查询、缓存策略等问题 |
-
-#### 3. 本地验证
-
-修复后必须在本地验证：
-```bash
-# 使用 Taskfile（推荐）
-task lint && task build && task test && task coverage
-
-# 或手动执行
-cd backend
-go vet ./... && go build ./... && golangci-lint run && go test ./... -v
-go test ./... -coverprofile=coverage.out
-go tool cover -func=coverage.out | grep total  # 确保 >= 90%
-```
-
-#### 4. 自动重新提交审查
-
-✅ **修复并验证通过后，必须自动调用 `/code-reviewer` 重新审查**：
-
-```
-/code-reviewer 后端修复已完成，请重新执行代码审查：
-
-修复内容：
-- [具体修复的问题描述]
-- [修改的文件列表]
-
-本地验证结果：
-- 编译：✅ 通过
-- Lint：✅ 通过
-- 单元测试：✅ 全部通过
-- 覆盖率：✅ XX% (>= 90%)
-```
-
-⚠️ **重要**：修复完成后 **必须自动调用 `/code-reviewer`**，无需等待人工指令！
-
-## 代码规范
-
-### 项目结构
-
-```
-backend/
-├── cmd/                    # 应用入口
-│   └── server/
-│       └── main.go
-├── internal/
-│   ├── api/               # HTTP handlers
-│   │   └── [resource]_handler.go
-│   ├── service/           # 业务逻辑
-│   │   └── [resource]_service.go
-│   ├── repository/        # 数据访问
-│   │   └── [resource]_repository.go
-│   └── model/             # 数据模型
-│       └── [resource].go
-├── pkg/                   # 可复用的公共库
-│   ├── middleware/
-│   ├── config/
-│   └── utils/
-├── migrations/            # 数据库迁移
-│   └── 001_create_[table].sql
-└── tests/                 # 测试
-    └── integration/
-```
-
-### 命名规范
-
-- **包名**: 小写，单数形式（如 `user`, `product`）
-- **文件名**: 小写，下划线分隔（如 `user_handler.go`, `user_service.go`）
-- **接口**: 以 `er` 结尾（如 `UserRepository`, `EmailSender`）
-- **结构体**: 大驼峰（如 `UserService`, `ProductHandler`）
-- **方法和函数**: 大驼峰（导出）或小驼峰（私有）
-- **常量**: 全大写或大驼峰（如 `MaxRetries`, `DefaultTimeout`）
-- **错误变量**: 以 `Err` 开头（如 `ErrUserNotFound`, `ErrInvalidInput`）
-
-### API 设计规范
-
-**RESTful 风格**:
-```go
-GET    /api/v1/users          // 获取用户列表
-GET    /api/v1/users/{id}     // 获取单个用户
-POST   /api/v1/users          // 创建用户
-PUT    /api/v1/users/{id}     // 更新用户
-DELETE /api/v1/users/{id}     // 删除用户
-```
-
-**标准响应格式**:
-```go
-// 成功响应
-{
-  "code": 0,
-  "message": "success",
-  "data": { ... }
-}
-
-// 错误响应
-{
-  "code": 4001,
-  "message": "user not found",
-  "data": null
-}
-```
-
-**参数验证**:
-```go
-type CreateUserRequest struct {
-    Email    string `json:"email" binding:"required,email"`
-    Password string `json:"password" binding:"required,min=8"`
-    Name     string `json:"name" binding:"required,max=100"`
-}
-```
-
-### 数据库规范
-
-**表命名**: 小写复数（如 `users`, `products`）
-**字段命名**: 小写下划线（如 `created_at`, `user_id`）
-**必备字段**:
-```go
-type BaseModel struct {
-    ID        uint      `gorm:"primaryKey"`
-    CreatedAt time.Time `gorm:"autoCreateTime"`
-    UpdatedAt time.Time `gorm:"autoUpdateTime"`
-}
-```
-
-**索引设计**:
-- 主键索引：自动创建
-- 外键索引：关联字段
-- 唯一索引：邮箱、用户名等
-- 普通索引：频繁查询字段
-
-### 错误处理
-
-```go
-// 定义业务错误
-var (
-    ErrUserNotFound = errors.New("user not found")
-    ErrInvalidInput = errors.New("invalid input")
-)
-
-// 使用 errors.Is 判断错误类型
-if errors.Is(err, ErrUserNotFound) {
-    return c.JSON(404, Response{Code: 4004, Message: err.Error()})
-}
-```
-
-### 日志规范
-
-使用结构化日志（如 zap, zerolog）:
-```go
-log.Info("user created",
-    zap.String("email", user.Email),
-    zap.Uint("id", user.ID),
-)
-```
-
-## 性能要求
-
-- **API 响应时间**: < 200ms (P95)
-- **并发处理能力**: >= 1000 QPS
-- **数据库查询**: 避免 N+1 查询，使用预加载
-- **缓存策略**:
-  - 热点数据使用 Redis 缓存
-  - 设置合理的过期时间
-  - 缓存穿透防护
-
-### 并发控制
-
-```go
-// 使用 goroutine 池控制并发
-pool := NewWorkerPool(10)
-for _, item := range items {
-    pool.Submit(func() {
-        process(item)
-    })
-}
-pool.Wait()
-```
-
-## 安全实践
-
-### 1. SQL 注入防护
-```go
-// ✅ 正确：使用参数化查询
-db.Where("email = ?", email).First(&user)
-
-// ❌ 错误：拼接 SQL
-db.Raw("SELECT * FROM users WHERE email = '" + email + "'")
-```
-
-### 2. 输入验证
-```go
-// 使用 validator 进行参数验证
-if err := c.ShouldBindJSON(&req); err != nil {
-    return c.JSON(400, Response{Code: 4000, Message: err.Error()})
-}
-```
-
-### 3. 密码安全
-```go
-// 使用 bcrypt 加密密码
-hashedPassword, _ := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
-
-// 验证密码
-err := bcrypt.CompareHashAndPassword(hashedPassword, []byte(inputPassword))
-```
-
-### 4. JWT 认证
-```go
-// 生成 Token
-token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
-    "user_id": user.ID,
-    "exp":     time.Now().Add(7 * 24 * time.Hour).Unix(),
-})
-```
-
-### 5. CORS 配置
-```go
-config := cors.DefaultConfig()
-config.AllowOrigins = []string{"https://yourdomain.com"}
-router.Use(cors.New(config))
-```
-
-## 测试要求
-
-### 单元测试
-
-**覆盖率**: >= 90%
-**测试框架**: testify
-
-```go
-func TestUserService_CreateUser(t *testing.T) {
-    // 表驱动测试
-    tests := []struct {
-        name    string
-        input   CreateUserRequest
-        wantErr bool
-    }{
-        {"valid user", CreateUserRequest{Email: "test@example.com"}, false},
-        {"invalid email", CreateUserRequest{Email: "invalid"}, true},
-    }
-
-    for _, tt := range tests {
-        t.Run(tt.name, func(t *testing.T) {
-            err := service.CreateUser(tt.input)
-            if (err != nil) != tt.wantErr {
-                t.Errorf("CreateUser() error = %v, wantErr %v", err, tt.wantErr)
-            }
-        })
-    }
-}
-```
-
-### Mock 外部依赖
-
-使用 gomock:
-```go
-mockRepo := mock.NewMockUserRepository(ctrl)
-mockRepo.EXPECT().FindByEmail("test@example.com").Return(&user, nil)
-```
-
-## 评审指南
-
-**仅在需要评审时加载**: 当需要对后端 OpenSpec 或代码实现进行评审时，请参考 `@/references/backend-review-guide.md`
-
-该评审指南提供：
-- API 设计评审标准（RESTful 规范）
-- 数据模型和数据库设计评审要点
-- 安全性评审（SQL注入、XSS、密码加密等）
-- 性能评审（N+1查询、索引、缓存等）
-- 测试覆盖率评审标准（>= 90%）
-- 评审记录模板和流程
-
-**何时需要评审**:
-- Backend OpenSpec 已生成，需要评审验证
-- 用户明确要求对后端 OpenSpec 进行评审
-- 代码实现完成，需要对照 OpenSpec 进行符合性评审
-
-## 与其他 Skills 的协作
-
-1. **上游**: 接收 SAE 生成的需求规格
-2. **并行**: 与 Frontend Engineer 并行工作，通过 API 契约协作
-3. **下游**: 代码完成后交给 Code Reviewer 进行代码审查
-4. **修复循环**:
-   - 收到 Code Reviewer 或 Tester 修复请求 → 修复问题 → 本地验证 → **自动调用** `/code-reviewer` 重新审查
-   - Code Reviewer 通过后流转到 Tester，Tester 通过后流转到 Git Engineer
-
-## 会话管理
-
-⚠️ **注意**：Backend Engineer **不触发** `/compact` 命令。
-
-### 为什么不触发 /compact
-
-- Backend Engineer 不是工作流的终点，后续还有 Code Reviewer → Tester → Git Engineer
-- 在修复循环中保持上下文连续性很重要（修复轮次、错误历史等）
-- `/compact` 只在工作流的**起点**（SAE）和**终点**（Git Engineer MR 成功）触发
-
-### 何时会触发 /compact
-
-- 当整个工作流完成时（Git Engineer MR 创建成功）
-- 当达到最大修复轮次需要人工介入时
-
-## 在 Pre-Execution Review 中的角色
-
-提供后端技术评估：
-- 技术可行性分析
-- 依赖风险识别（是否需要新依赖？）
-- 性能预估（QPS、响应时间）
-- 数据库设计复杂度
-- 预计需要人工介入的部分
-
-## 示例对话
-
-```
-我（Backend Engineer）:
-
-已读取需求规格：specs/requirements/user-login.md
-
-我现在生成后端 OpenSpec...
-
-[调用 openspec:proposal]
-
-✅ 后端 OpenSpec 已生成
-
-包含内容：
-- API 端点：POST /api/v1/auth/login
-- 请求参数：email, password
-- 响应：JWT token, 用户信息
-- 数据库表：users (id, email, password_hash, created_at, updated_at)
-- 索引：email (唯一索引)
-- 单元测试：10 个测试用例（邮箱/手机号登录、密码错误、用户不存在等）
-
-请批准 OpenSpec，我将开始实现代码。
-
-[用户批准后]
-
-开始实现后端代码...
-
-[调用 openspec:apply]
-
-✅ 后端代码已实现
-
-文件：
-- backend/internal/api/auth_handler.go
-- backend/internal/service/auth_service.go
-- backend/internal/repository/user_repository.go
-- backend/internal/model/user.go
-- backend/tests/auth_test.go
-
-测试覆盖率：92%
-
-代码已提交到分支：feature/user-login
-
-下一步请 Code Reviewer 进行代码审查。
-```