feat(skills): add CCW orchestrator and refactor command-guide to ccw-help

CCW Skill (new):
- Stateless workflow orchestrator with intent classification
- 6 workflow combinations: rapid, full, coupled, bugfix, issue, ui
- External configuration: intent-rules.json, workflow-chains.json
- Implicit CLI tool injection (Gemini/Qwen/Codex)
- TODO tracking integration for workflow progress

CCW-Help Skill (refactored from command-guide):
- Renamed command-guide → ccw-help
- Removed reference folder duplication
- Source paths now relative from index/ (../../../commands/...)
- Added all-agents.json index
- Simplified SKILL.md following CCW pattern
This commit is contained in:
catlog22
2026-01-03 18:46:59 +08:00
parent ad6c18f615
commit e3dba87e08
122 changed files with 4293 additions and 42193 deletions

View File

@@ -0,0 +1,218 @@
# Action: Bugfix Workflow
缺陷修复工作流:智能诊断 + 影响评估 + 修复
## Pattern
```
lite-fix [--hotfix]
```
## Trigger Conditions
- Keywords: "fix", "bug", "error", "crash", "broken", "fail", "修复", "报错"
- Problem symptoms described
- Error messages present
## Execution Flow
### Standard Mode
```mermaid
sequenceDiagram
participant U as User
participant O as CCW Orchestrator
participant LF as lite-fix
participant CLI as CLI Tools
U->>O: Bug description
O->>O: Classify: bugfix (standard)
O->>LF: /workflow:lite-fix "bug"
Note over LF: Phase 1: Diagnosis
LF->>CLI: Root cause analysis (Gemini)
CLI-->>LF: diagnosis.json
Note over LF: Phase 2: Impact Assessment
LF->>LF: Risk scoring (0-10)
LF->>LF: Severity classification
LF-->>U: Impact report
Note over LF: Phase 3: Fix Strategy
LF->>LF: Generate fix options
LF-->>U: Present strategies
U->>LF: Select strategy
Note over LF: Phase 4: Verification Plan
LF->>LF: Generate test plan
LF-->>U: Verification approach
Note over LF: Phase 5: Confirmation
LF->>U: Execution method?
U->>LF: Confirm
Note over LF: Phase 6: Execute
LF->>CLI: Execute fix (Agent/Codex)
CLI-->>LF: Results
LF-->>U: Fix complete
```
### Hotfix Mode
```mermaid
sequenceDiagram
participant U as User
participant O as CCW Orchestrator
participant LF as lite-fix
participant CLI as CLI Tools
U->>O: Urgent bug + "hotfix"
O->>O: Classify: bugfix (hotfix)
O->>LF: /workflow:lite-fix --hotfix "bug"
Note over LF: Minimal Diagnosis
LF->>CLI: Quick root cause
CLI-->>LF: Known issue?
Note over LF: Surgical Fix
LF->>LF: Single optimal fix
LF-->>U: Quick confirmation
U->>LF: Proceed
Note over LF: Smoke Test
LF->>CLI: Minimal verification
CLI-->>LF: Pass/Fail
Note over LF: Follow-up Generation
LF->>LF: Generate follow-up tasks
LF-->>U: Fix deployed + follow-ups created
```
## When to Use
### Standard Mode (/workflow:lite-fix)
**Use for**:
- 已知症状的 Bug
- 本地化修复1-5 文件)
- 非紧急问题
- 需要完整诊断
### Hotfix Mode (/workflow:lite-fix --hotfix)
**Use for**:
- 生产事故
- 紧急修复
- 明确的单点故障
- 时间敏感
**Don't use** (for either mode):
- 需要架构变更 → `/workflow:plan --mode bugfix`
- 多个相关问题 → `/issue:plan`
## Severity Classification
| Score | Severity | Response | Verification |
|-------|----------|----------|--------------|
| 8-10 | Critical | Immediate | Smoke test only |
| 6-7.9 | High | Fast track | Integration tests |
| 4-5.9 | Medium | Normal | Full test suite |
| 0-3.9 | Low | Scheduled | Comprehensive |
## Configuration
```javascript
const bugfixConfig = {
standard: {
diagnosis: {
tool: 'gemini',
depth: 'comprehensive',
timeout: 300000 // 5 min
},
impact: {
riskThreshold: 6.0, // High risk threshold
autoEscalate: true
},
verification: {
levels: ['smoke', 'integration', 'full'],
autoSelect: true // Based on severity
}
},
hotfix: {
diagnosis: {
tool: 'gemini',
depth: 'minimal',
timeout: 60000 // 1 min
},
fix: {
strategy: 'single', // Single optimal fix
surgical: true
},
followup: {
generate: true,
types: ['comprehensive-fix', 'post-mortem']
}
}
}
```
## Example Invocations
```bash
# Standard bug fix
ccw "用户头像上传失败,返回 413 错误"
→ lite-fix
→ Diagnosis: File size limit in nginx
→ Impact: 6.5 (High)
→ Fix: Update nginx config + add client validation
→ Verify: Integration test
# Production hotfix
ccw "紧急:支付网关返回 5xx 错误,影响所有用户"
→ lite-fix --hotfix
→ Quick diagnosis: API key expired
→ Surgical fix: Rotate key
→ Smoke test: Payment flow
→ Follow-ups: Key rotation automation, monitoring alert
# Unknown root cause
ccw "购物车随机丢失商品,原因不明"
→ lite-fix
→ Deep diagnosis (auto)
→ Root cause: Race condition in concurrent updates
→ Fix: Add optimistic locking
→ Verify: Concurrent test suite
```
## Output Artifacts
```
.workflow/.lite-fix/{bug-slug}-{timestamp}/
├── diagnosis.json # Root cause analysis
├── impact.json # Risk assessment
├── fix-plan.json # Fix strategy
├── task.json # Enhanced task for execution
└── followup.json # Follow-up tasks (hotfix only)
```
## Follow-up Tasks (Hotfix Mode)
```json
{
"followups": [
{
"id": "FOLLOWUP-001",
"type": "comprehensive-fix",
"title": "Complete fix for payment gateway issue",
"due": "3 days",
"description": "Implement full solution with proper error handling"
},
{
"id": "FOLLOWUP-002",
"type": "post-mortem",
"title": "Post-mortem analysis",
"due": "1 week",
"description": "Document incident and prevention measures"
}
]
}
```

View File

@@ -0,0 +1,194 @@
# Action: Coupled Workflow
复杂耦合工作流:完整规划 + 验证 + 执行
## Pattern
```
plan → action-plan-verify → execute
```
## Trigger Conditions
- Complexity: High
- Keywords: "refactor", "重构", "migrate", "迁移", "architect", "架构"
- Cross-module changes
- System-level modifications
## Execution Flow
```mermaid
sequenceDiagram
participant U as User
participant O as CCW Orchestrator
participant PL as plan
participant VF as verify
participant EX as execute
participant RV as review
U->>O: Complex task
O->>O: Classify: coupled (high complexity)
Note over PL: Phase 1: Comprehensive Planning
O->>PL: /workflow:plan
PL->>PL: Multi-phase planning
PL->>PL: Generate IMPL_PLAN.md
PL->>PL: Generate task JSONs
PL-->>U: Present plan
Note over VF: Phase 2: Verification
U->>VF: /workflow:action-plan-verify
VF->>VF: Cross-artifact consistency
VF->>VF: Dependency validation
VF->>VF: Quality gate checks
VF-->>U: Verification report
alt Verification failed
U->>PL: Replan with issues
else Verification passed
Note over EX: Phase 3: Execution
U->>EX: /workflow:execute
EX->>EX: DAG-based parallel execution
EX-->>U: Execution complete
end
Note over RV: Phase 4: Review
U->>RV: /workflow:review
RV-->>U: Review findings
```
## When to Use
**Ideal scenarios**:
- 大规模重构
- 架构迁移
- 跨模块功能开发
- 技术栈升级
- 团队协作项目
**Avoid when**:
- 简单的局部修改
- 时间紧迫
- 独立的小功能
## Verification Checks
| Check | Description | Severity |
|-------|-------------|----------|
| Dependency Cycles | 检测循环依赖 | Critical |
| Missing Tasks | 计划与实际不符 | High |
| File Conflicts | 多任务修改同文件 | Medium |
| Coverage Gaps | 未覆盖的需求 | Medium |
## Configuration
```javascript
const coupledConfig = {
plan: {
phases: 5, // Full 5-phase planning
taskGeneration: 'action-planning-agent',
outputFormat: {
implPlan: '.workflow/plans/IMPL_PLAN.md',
taskJsons: '.workflow/tasks/IMPL-*.json'
}
},
verify: {
required: true, // Always verify before execute
autoReplan: false, // Manual replan on failure
qualityGates: ['no-cycles', 'no-conflicts', 'complete-coverage']
},
execute: {
dagParallel: true,
checkpointInterval: 3, // Checkpoint every 3 tasks
rollbackOnFailure: true
},
review: {
types: ['architecture', 'security'],
required: true
}
}
```
## Task JSON Structure
```json
{
"id": "IMPL-001",
"title": "重构认证模块核心逻辑",
"scope": "src/auth/**",
"action": "refactor",
"depends_on": [],
"modification_points": [
{
"file": "src/auth/service.ts",
"target": "AuthService",
"change": "Extract OAuth2 logic"
}
],
"acceptance": [
"所有现有测试通过",
"OAuth2 流程可用"
]
}
```
## Example Invocations
```bash
# Architecture refactoring
ccw "重构整个认证模块,从 session 迁移到 JWT"
→ plan (5 phases)
→ verify
→ execute
# System migration
ccw "将数据库从 MySQL 迁移到 PostgreSQL"
→ plan (migration strategy)
→ verify (data integrity checks)
→ execute (staged migration)
# Cross-module feature
ccw "实现跨服务的分布式事务支持"
→ plan (architectural design)
→ verify (consistency checks)
→ execute (incremental rollout)
```
## Output Artifacts
```
.workflow/
├── plans/
│ └── IMPL_PLAN.md # Comprehensive plan
├── tasks/
│ ├── IMPL-001.json
│ ├── IMPL-002.json
│ └── ...
├── verify/
│ └── verification-report.md # Verification results
└── reviews/
└── {review-type}.md # Review findings
```
## Replan Flow
When verification fails:
```javascript
if (verificationResult.status === 'failed') {
console.log(`
## Verification Failed
**Issues found**:
${verificationResult.issues.map(i => `- ${i.severity}: ${i.message}`).join('\n')}
**Options**:
1. /workflow:replan - Address issues and regenerate plan
2. /workflow:plan --force - Proceed despite issues (not recommended)
3. Review issues manually and fix plan files
`)
}
```

View File

@@ -0,0 +1,93 @@
# Documentation Workflow Action
## Pattern
```
memory:docs → execute (full)
memory:update-related (incremental)
```
## Trigger Conditions
- 关键词: "文档", "documentation", "docs", "readme", "注释"
- 变体触发:
- `incremental`: "更新", "增量", "相关"
- `full`: "全部", "完整", "所有"
## Variants
### Full Documentation
```mermaid
graph TD
A[User Input] --> B[memory:docs]
B --> C[项目结构分析]
C --> D[模块分组 ≤10/task]
D --> E[execute: 并行生成]
E --> F[README.md]
E --> G[ARCHITECTURE.md]
E --> H[API Docs]
E --> I[Module CLAUDE.md]
```
### Incremental Update
```mermaid
graph TD
A[Git Changes] --> B[memory:update-related]
B --> C[变更模块检测]
C --> D[相关文档定位]
D --> E[增量更新]
```
## Configuration
| 参数 | 默认值 | 说明 |
|------|--------|------|
| batch_size | 4 | 每agent处理模块数 |
| format | markdown | 输出格式 |
| include_api | true | 生成API文档 |
| include_diagrams | true | 生成Mermaid图 |
## CLI Integration
| 阶段 | CLI Hint | 用途 |
|------|----------|------|
| memory:docs | `gemini --mode analysis` | 项目结构分析 |
| execute | `gemini --mode write` | 文档生成 |
| update-related | `gemini --mode write` | 增量更新 |
## Slash Commands
```bash
/memory:docs # 规划全量文档生成
/memory:docs-full-cli # CLI执行全量文档
/memory:docs-related-cli # CLI执行增量文档
/memory:update-related # 更新变更相关文档
/memory:update-full # 更新所有CLAUDE.md
```
## Output Structure
```
project/
├── README.md # 项目概览
├── ARCHITECTURE.md # 架构文档
├── docs/
│ └── api/ # API文档
└── src/
└── module/
└── CLAUDE.md # 模块文档
```
## When to Use
- 新项目初始化文档
- 大版本发布前文档更新
- 代码变更后同步文档
- API文档生成
## Risk Assessment
| 风险 | 缓解措施 |
|------|----------|
| 文档与代码不同步 | git hook集成 |
| 生成内容过于冗长 | batch_size控制 |
| 遗漏重要模块 | 全量扫描验证 |

View File

@@ -0,0 +1,154 @@
# Action: Full Workflow
完整探索工作流:分析 + 头脑风暴 + 规划 + 执行
## Pattern
```
brainstorm:auto-parallel → plan → [verify] → execute
```
## Trigger Conditions
- Intent: Exploration (uncertainty detected)
- Keywords: "不确定", "不知道", "explore", "怎么做", "what if"
- No clear implementation path
## Execution Flow
```mermaid
sequenceDiagram
participant U as User
participant O as CCW Orchestrator
participant BS as brainstorm
participant PL as plan
participant VF as verify
participant EX as execute
U->>O: Unclear task
O->>O: Classify: full
Note over BS: Phase 1: Brainstorm
O->>BS: /workflow:brainstorm:auto-parallel
BS->>BS: Multi-role parallel analysis
BS->>BS: Synthesis & recommendations
BS-->>U: Present options
U->>BS: Select direction
Note over PL: Phase 2: Plan
BS->>PL: /workflow:plan
PL->>PL: Generate IMPL_PLAN.md
PL->>PL: Generate task JSONs
PL-->>U: Review plan
Note over VF: Phase 3: Verify (optional)
U->>VF: /workflow:action-plan-verify
VF->>VF: Cross-artifact consistency
VF-->>U: Verification report
Note over EX: Phase 4: Execute
U->>EX: /workflow:execute
EX->>EX: DAG-based parallel execution
EX-->>U: Execution complete
```
## When to Use
**Ideal scenarios**:
- 产品方向探索
- 技术选型评估
- 架构设计决策
- 复杂功能规划
- 需要多角色视角
**Avoid when**:
- 任务明确简单
- 时间紧迫
- 已有成熟方案
## Brainstorm Roles
| Role | Focus | Typical Questions |
|------|-------|-------------------|
| Product Manager | 用户价值、市场定位 | "用户痛点是什么?" |
| System Architect | 技术方案、架构设计 | "如何保证可扩展性?" |
| UX Expert | 用户体验、交互设计 | "用户流程是否顺畅?" |
| Security Expert | 安全风险、合规要求 | "有哪些安全隐患?" |
| Data Architect | 数据模型、存储方案 | "数据如何组织?" |
## Configuration
```javascript
const fullConfig = {
brainstorm: {
defaultRoles: ['product-manager', 'system-architect', 'ux-expert'],
maxRoles: 5,
synthesis: true // Always generate synthesis
},
plan: {
verifyBeforeExecute: true, // Recommend verification
taskFormat: 'json' // Generate task JSONs
},
execute: {
dagParallel: true, // DAG-based parallel execution
testGeneration: 'optional' // Suggest test-gen after
}
}
```
## Continuation Points
After each phase, CCW can continue to the next:
```javascript
// After brainstorm completes
console.log(`
## Brainstorm Complete
**Next steps**:
1. /workflow:plan "基于头脑风暴结果规划实施"
2. Or refine: /workflow:brainstorm:synthesis
`)
// After plan completes
console.log(`
## Plan Complete
**Next steps**:
1. /workflow:action-plan-verify (recommended)
2. /workflow:execute (直接执行)
`)
```
## Example Invocations
```bash
# Product exploration
ccw "我想做一个团队协作工具,但不确定具体方向"
→ brainstorm:auto-parallel (5 roles)
→ plan
→ execute
# Technical exploration
ccw "如何设计一个高可用的消息队列系统?"
→ brainstorm:auto-parallel (system-architect, data-architect)
→ plan
→ verify
→ execute
```
## Output Artifacts
```
.workflow/
├── brainstorm/
│ ├── {session}/
│ │ ├── role-{role}.md
│ │ └── synthesis.md
├── plans/
│ └── IMPL_PLAN.md
└── tasks/
└── IMPL-*.json
```

View File

@@ -0,0 +1,201 @@
# Action: Issue Workflow
Issue 批量处理工作流:规划 + 队列 + 批量执行
## Pattern
```
issue:plan → issue:queue → issue:execute
```
## Trigger Conditions
- Keywords: "issues", "batch", "queue", "多个", "批量"
- Multiple related problems
- Long-running fix campaigns
- Priority-based processing needed
## Execution Flow
```mermaid
sequenceDiagram
participant U as User
participant O as CCW Orchestrator
participant IP as issue:plan
participant IQ as issue:queue
participant IE as issue:execute
U->>O: Multiple issues / batch fix
O->>O: Classify: issue
Note over IP: Phase 1: Issue Planning
O->>IP: /issue:plan
IP->>IP: Load unplanned issues
IP->>IP: Generate solutions per issue
IP->>U: Review solutions
U->>IP: Bind selected solutions
Note over IQ: Phase 2: Queue Formation
IP->>IQ: /issue:queue
IQ->>IQ: Conflict analysis
IQ->>IQ: Priority calculation
IQ->>IQ: DAG construction
IQ->>U: High-severity conflicts?
U->>IQ: Resolve conflicts
IQ->>IQ: Generate execution queue
Note over IE: Phase 3: Execution
IQ->>IE: /issue:execute
IE->>IE: DAG-based parallel execution
IE->>IE: Per-solution progress tracking
IE-->>U: Batch execution complete
```
## When to Use
**Ideal scenarios**:
- 多个相关 Bug 需要批量修复
- GitHub Issues 批量处理
- 技术债务清理
- 安全漏洞批量修复
- 代码质量改进活动
**Avoid when**:
- 单一问题 → `/workflow:lite-fix`
- 独立不相关的任务 → 分别处理
- 紧急生产问题 → `/workflow:lite-fix --hotfix`
## Issue Lifecycle
```
draft → planned → queued → executing → completed
↓ ↓
skipped on-hold
```
## Conflict Types
| Type | Description | Resolution |
|------|-------------|------------|
| File | 多个解决方案修改同一文件 | Sequential execution |
| API | API 签名变更影响 | Dependency ordering |
| Data | 数据结构变更冲突 | User decision |
| Dependency | 包依赖冲突 | Version negotiation |
| Architecture | 架构方向冲突 | User decision (high severity) |
## Configuration
```javascript
const issueConfig = {
plan: {
solutionsPerIssue: 3, // Generate up to 3 solutions
autoSelect: false, // User must bind solution
planningAgent: 'issue-plan-agent'
},
queue: {
conflictAnalysis: true,
priorityCalculation: true,
clarifyThreshold: 'high', // Ask user for high-severity conflicts
queueAgent: 'issue-queue-agent'
},
execute: {
dagParallel: true,
executionLevel: 'solution', // Execute by solution, not task
executor: 'codex',
resumable: true
}
}
```
## Example Invocations
```bash
# From GitHub Issues
ccw "批量处理所有 label:bug 的 GitHub Issues"
→ issue:new (import from GitHub)
→ issue:plan (generate solutions)
→ issue:queue (form execution queue)
→ issue:execute (batch execute)
# Tech debt cleanup
ccw "处理所有 TODO 注释和已知技术债务"
→ issue:discover (find issues)
→ issue:plan (plan solutions)
→ issue:queue (prioritize)
→ issue:execute (execute)
# Security vulnerabilities
ccw "修复所有 npm audit 报告的安全漏洞"
→ issue:new (from audit report)
→ issue:plan (upgrade strategies)
→ issue:queue (conflict resolution)
→ issue:execute (staged upgrades)
```
## Queue Structure
```json
{
"queue_id": "QUE-20251227-143000",
"status": "active",
"execution_groups": [
{
"id": "P1",
"type": "parallel",
"solutions": ["SOL-ISS-001-1", "SOL-ISS-002-1"],
"description": "Independent fixes, no file overlap"
},
{
"id": "S1",
"type": "sequential",
"solutions": ["SOL-ISS-003-1"],
"depends_on": ["P1"],
"description": "Depends on P1 completion"
}
]
}
```
## Output Artifacts
```
.workflow/issues/
├── issues.jsonl # All issues (one per line)
├── solutions/
│ ├── ISS-001.jsonl # Solutions for ISS-001
│ └── ISS-002.jsonl
├── queues/
│ ├── index.json # Queue index
│ └── QUE-xxx.json # Queue details
└── execution/
└── {queue-id}/
├── progress.json
└── results/
```
## Progress Tracking
```javascript
// Real-time progress during execution
const progress = {
queue_id: "QUE-xxx",
total_solutions: 5,
completed: 2,
in_progress: 1,
pending: 2,
current_group: "P1",
eta: "15 minutes"
}
```
## Resume Capability
```bash
# If execution interrupted
ccw "继续执行 issue 队列"
→ Detects active queue: QUE-xxx
→ Resumes from last checkpoint
→ /issue:execute --resume
```

View File

@@ -0,0 +1,104 @@
# Action: Rapid Workflow
快速迭代工作流组合:多模型协作分析 + 直接执行
## Pattern
```
lite-plan → lite-execute
```
## Trigger Conditions
- Complexity: Low to Medium
- Intent: Feature development
- Context: Clear requirements, known implementation path
- No uncertainty keywords
## Execution Flow
```mermaid
sequenceDiagram
participant U as User
participant O as CCW Orchestrator
participant LP as lite-plan
participant LE as lite-execute
participant CLI as CLI Tools
U->>O: Task description
O->>O: Classify: rapid
O->>LP: /workflow:lite-plan "task"
LP->>LP: Complexity assessment
LP->>CLI: Parallel explorations (if needed)
CLI-->>LP: Exploration results
LP->>LP: Generate plan.json
LP->>U: Display plan, ask confirmation
U->>LP: Confirm + select execution method
LP->>LE: /workflow:lite-execute --in-memory
LE->>CLI: Execute tasks (Agent/Codex)
CLI-->>LE: Results
LE->>LE: Optional code review
LE-->>U: Execution complete
```
## When to Use
**Ideal scenarios**:
- 添加单一功能(如用户头像上传)
- 修改现有功能(如更新表单验证)
- 小型重构(如抽取公共方法)
- 添加测试用例
- 文档更新
**Avoid when**:
- 不确定实现方案
- 跨多个模块
- 需要架构决策
- 有复杂依赖关系
## Configuration
```javascript
const rapidConfig = {
explorationThreshold: {
// Force exploration if task mentions specific files
forceExplore: /\b(file|文件|module|模块|class|类)\s*[:]?\s*\w+/i,
// Skip exploration for simple tasks
skipExplore: /\b(add|添加|create|创建)\s+(comment|注释|log|日志)/i
},
defaultExecution: 'Agent', // Agent for low complexity
codeReview: {
default: 'Skip', // Skip review for simple tasks
threshold: 'medium' // Enable for medium+ complexity
}
}
```
## Example Invocations
```bash
# Simple feature
ccw "添加用户退出登录按钮"
→ lite-plan → lite-execute (Agent)
# With exploration
ccw "优化 AuthService 的 token 刷新逻辑"
→ lite-plan -e → lite-execute (Agent, Gemini review)
# Medium complexity
ccw "实现用户偏好设置的本地存储"
→ lite-plan -e → lite-execute (Codex)
```
## Output Artifacts
```
.workflow/.lite-plan/{task-slug}-{date}/
├── exploration-*.json # If exploration was triggered
├── explorations-manifest.json
└── plan.json # Implementation plan
```

View File

@@ -0,0 +1,84 @@
# Review-Fix Workflow Action
## Pattern
```
review-session-cycle → review-fix
```
## Trigger Conditions
- 关键词: "review", "审查", "检查代码", "code review", "质量检查"
- 场景: PR审查、代码质量提升、安全审计
## Execution Flow
```mermaid
graph TD
A[User Input] --> B[review-session-cycle]
B --> C{7维度分析}
C --> D[Security]
C --> E[Performance]
C --> F[Maintainability]
C --> G[Architecture]
C --> H[Code Style]
C --> I[Test Coverage]
C --> J[Documentation]
D & E & F & G & H & I & J --> K[Findings Aggregation]
K --> L{Quality Gate}
L -->|Pass| M[Report Only]
L -->|Fail| N[review-fix]
N --> O[Auto Fix]
O --> P[Re-verify]
```
## Configuration
| 参数 | 默认值 | 说明 |
|------|--------|------|
| dimensions | all | 审查维度(security,performance,etc.) |
| quality_gate | 80 | 质量门槛分数 |
| auto_fix | true | 自动修复发现的问题 |
| severity_threshold | medium | 最低关注级别 |
## CLI Integration
| 阶段 | CLI Hint | 用途 |
|------|----------|------|
| review-session-cycle | `gemini --mode analysis` | 多维度深度分析 |
| review-fix | `codex --mode write` | 自动修复问题 |
## Slash Commands
```bash
/workflow:review-session-cycle # 会话级代码审查
/workflow:review-module-cycle # 模块级代码审查
/workflow:review-fix # 自动修复审查发现
/workflow:review --type security # 专项安全审查
```
## Review Dimensions
| 维度 | 检查点 |
|------|--------|
| Security | 注入、XSS、敏感数据暴露 |
| Performance | N+1查询、内存泄漏、算法复杂度 |
| Maintainability | 代码重复、复杂度、命名 |
| Architecture | 依赖方向、层级违规、耦合度 |
| Code Style | 格式、约定、一致性 |
| Test Coverage | 覆盖率、边界用例 |
| Documentation | 注释、API文档、README |
## When to Use
- PR合并前审查
- 重构后质量验证
- 安全合规审计
- 技术债务评估
## Risk Assessment
| 风险 | 缓解措施 |
|------|----------|
| 误报过多 | severity_threshold过滤 |
| 修复引入新问题 | re-verify循环 |
| 审查不全面 | 7维度覆盖 |

View File

@@ -0,0 +1,66 @@
# TDD Workflow Action
## Pattern
```
tdd-plan → execute → tdd-verify
```
## Trigger Conditions
- 关键词: "tdd", "test-driven", "测试驱动", "先写测试", "red-green"
- 场景: 需要高质量代码保证、关键业务逻辑、回归风险高
## Execution Flow
```mermaid
graph TD
A[User Input] --> B[tdd-plan]
B --> C{生成测试任务链}
C --> D[Red Phase: 写失败测试]
D --> E[execute: 实现代码]
E --> F[Green Phase: 测试通过]
F --> G{需要重构?}
G -->|Yes| H[Refactor Phase]
H --> F
G -->|No| I[tdd-verify]
I --> J[质量报告]
```
## Configuration
| 参数 | 默认值 | 说明 |
|------|--------|------|
| coverage_target | 80% | 目标覆盖率 |
| cycle_limit | 10 | 最大Red-Green-Refactor循环 |
| strict_mode | false | 严格模式(必须先红后绿) |
## CLI Integration
| 阶段 | CLI Hint | 用途 |
|------|----------|------|
| tdd-plan | `gemini --mode analysis` | 分析测试策略 |
| execute | `codex --mode write` | 实现代码 |
| tdd-verify | `gemini --mode analysis` | 验证TDD合规性 |
## Slash Commands
```bash
/workflow:tdd-plan # 生成TDD任务链
/workflow:execute # 执行Red-Green-Refactor
/workflow:tdd-verify # 验证TDD合规性+覆盖率
```
## When to Use
- 核心业务逻辑开发
- 需要高测试覆盖率的模块
- 重构现有代码时确保不破坏功能
- 团队要求TDD实践
## Risk Assessment
| 风险 | 缓解措施 |
|------|----------|
| 测试粒度不当 | tdd-plan阶段评估测试边界 |
| 过度测试 | 聚焦行为而非实现 |
| 循环过多 | cycle_limit限制 |

View File

@@ -0,0 +1,79 @@
# UI Design Workflow Action
## Pattern
```
ui-design:[explore|imitate]-auto → design-sync → plan → execute
```
## Trigger Conditions
- 关键词: "ui", "界面", "design", "组件", "样式", "布局", "前端"
- 变体触发:
- `imitate`: "参考", "模仿", "像", "类似"
- `explore`: 无特定参考时默认
## Variants
### Explore (探索式设计)
```mermaid
graph TD
A[User Input] --> B[ui-design:explore-auto]
B --> C[设计系统分析]
C --> D[组件结构规划]
D --> E[design-sync]
E --> F[plan]
F --> G[execute]
```
### Imitate (参考式设计)
```mermaid
graph TD
A[User Input + Reference] --> B[ui-design:imitate-auto]
B --> C[参考分析]
C --> D[风格提取]
D --> E[design-sync]
E --> F[plan]
F --> G[execute]
```
## Configuration
| 参数 | 默认值 | 说明 |
|------|--------|------|
| design_system | auto | 设计系统(auto/tailwind/mui/custom) |
| responsive | true | 响应式设计 |
| accessibility | true | 无障碍支持 |
## CLI Integration
| 阶段 | CLI Hint | 用途 |
|------|----------|------|
| explore/imitate | `gemini --mode analysis` | 设计分析、风格提取 |
| design-sync | - | 设计决策与代码库同步 |
| plan | - | 内置规划 |
| execute | `codex --mode write` | 组件实现 |
## Slash Commands
```bash
/workflow:ui-design:explore-auto # 探索式UI设计
/workflow:ui-design:imitate-auto # 参考式UI设计
/workflow:ui-design:design-sync # 设计与代码同步(关键步骤)
/workflow:ui-design:style-extract # 提取现有样式
/workflow:ui-design:codify-style # 样式代码化
```
## When to Use
- 新页面/组件开发
- UI重构或现代化
- 设计系统建立
- 参考其他产品设计
## Risk Assessment
| 风险 | 缓解措施 |
|------|----------|
| 设计不一致 | style-extract确保复用 |
| 响应式问题 | 多断点验证 |
| 可访问性缺失 | a11y检查集成 |