aigroup-workflow 2.1.1 → 2.2.0

package/skills/requirement-engineering/SKILL.md

@@ -1,111 +0,0 @@
----
-name: requirement-engineering
-description: 需求工程 — 在任何创造性工作之前使用。通过协作对话收集需求、系统性验证、产出可作为设计和开发基准的需求文档。
----
-
-# 需求工程
-
-把模糊想法转化为完整、无歧义、可验证的需求文档。包含两个阶段：**收集**（brainstorming）和**验证**（validation）。
-
-> 只负责"要做什么"，不负责"怎么做"——技术方案在 `architecture-designer` / `writing-plans` 完成。
-
-## 协调
-
-```bash
-# 建 session（若尚未创建）
-node scripts/orchestration/session.cjs init <任务名>
-# 需求文档写入 .orchestration/<session>/architect/requirements.md
-# 验证结论追加到同文件；通过后进入方案设计 phase
-```
-
-## 阶段 1：收集（brainstorming）
-
-1. **探索项目上下文** — 读 文件、文档、近期提交，了解现状
-2. **逐个提问澄清** — 每条消息**只问一个问题**，优先选择题
-3. **识别用户场景** — 谁用？什么场景？期望什么结果？
-4. **定义功能边界** — 做什么、不做什么、优先级
-5. **撰写需求文档** — 保存到 `.orchestration/<session>/architect/requirements.md`
-
-### 需求文档结构
-
-```markdown
-# [功能名] 需求文档
-
-## 背景与目的
-为什么做？解决什么问题？
-
-## 用户场景
-- 场景 1：作为 [角色]，我希望 [行为]，以便 [价值]
-
-## 功能需求（每条可验证）
-- [ ] FR-1：[具体描述 + 通过/不通过标准]
-
-## 约束条件
-- 性能 / 兼容性 / 安全要求
-
-## 非功能需求
-- ...
-
-## 范围排除（不做什么）
-- ...
-
-## 成功标准
-- ...
-```
-
-## 阶段 2：验证（validation）
-
-对收集到的需求逐条验证，不通过不得进入设计。
-
-| 维度 | 检查项 |
-|------|--------|
-| 完整性 | 每场景有对应 FR？异常/非功能需求齐全？范围排除明确？ |
-| 可行性 | 技术可实现？时间合理？与现有系统兼容？ |
-| 无歧义性 | 每条只有一种理解？数值/行为边界明确（"快速"→"200ms 内"）？ |
-| 一致性 | 条目间有矛盾？约束冲突？优先级清晰？ |
-| 可验证性 | 有明确通过/不通过标准？ |
-
-### 验证结论（追加到需求文档末尾）
-
-```markdown
----
-
-## 需求验证结论
-
-**验证日期**：YYYY-MM-DD
-**结论**：通过 / 有条件通过 / 不通过
-
-- [x] 完整性 / 可行性 / 无歧义性 / 一致性 / 可验证性：通过
-
-### 发现的问题（如有）
-1. [问题] → [修正方案]
-
-### 修改记录
-- [修改内容]
-```
-
-## 铁律
-
-1. 此阶段不做技术方案设计、不选择技术栈、不讨论架构
-2. 每条消息只问一个问题
-3. 每条需求必须可验证（明确通过/不通过标准）
-4. 必须产出需求文档并获得用户确认才能推进
-5. 验证发现的问题必须**现场修正**，不得留到后续阶段
-
-## Red Flags — 停下来
-
-| 信号 | 行动 |
-|------|------|
-| 开始讨论技术方案 | 技术方案属于设计阶段，打住 |
-| 用户说"直接做吧" | 先完成最小需求文档 |
-| 需求描述了多个独立系统 | 先帮用户拆解为子项目 |
-| 需求中有"待定""之后再说" | 现在确定或标记为**明确的开放问题** |
-| 需求可以被两种方式理解 | 选定一种并明确 |
-| 需求之间有矛盾 | 与用户澄清并修正 |
-| 想跳过用户确认 | 用户确认是必须的门禁 |
-| 想跳过验证直接设计 | 不允许 |
-
-## 与其他 skill 的协作
-
-- 若涉及 UI/UX，可派遣对应 design agent 参与需求收集
-- 通过验证的需求文档是 `architecture-designer` / `writing-plans` 的核心输入

package/skills/rust-engineer/SKILL.md

@@ -1,167 +0,0 @@
----
-name: rust-engineer
-description: Writes, reviews, and debugs idiomatic Rust code with memory safety and zero-cost abstractions. Implements ownership patterns, manages lifetimes, designs trait hierarchies, builds async applications with tokio, and structures error handling with Result/Option. Use when building Rust applications, solving ownership or borrowing issues, designing trait-based APIs, implementing async/await concurrency, creating FFI bindings, or optimizing for performance and memory safety. Invoke for Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: language
-  triggers: Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: test-master
----
-
-# Rust Engineer
-
-Senior Rust engineer with deep expertise in Rust 2021 edition, systems programming, memory safety, and zero-cost abstractions. Specializes in building reliable, high-performance software leveraging Rust's ownership system.
-
-## Core Workflow
-
-1. **Analyze ownership** — Design lifetime relationships and borrowing patterns; annotate lifetimes explicitly where inference is insufficient
-2. **Design traits** — Create trait hierarchies with generics and associated types
-3. **Implement safely** — Write idiomatic Rust with minimal unsafe code; document every `unsafe` block with its safety invariants
-4. **Handle errors** — Use `Result`/`Option` with `?` operator and custom error types via `thiserror`
-5. **Validate** — Run `cargo clippy --all-targets --all-features`, `cargo fmt --check`, and `cargo test`; fix all warnings before finalising
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Ownership | `references/ownership.md` | Lifetimes, borrowing, smart pointers, Pin |
-| Traits | `references/traits.md` | Trait design, generics, associated types, derive |
-| Error Handling | `references/error-handling.md` | Result, Option, ?, custom errors, thiserror |
-| Async | `references/async.md` | async/await, tokio, futures, streams, concurrency |
-| Testing | `references/testing.md` | Unit/integration tests, proptest, benchmarks |
-
-## Key Patterns with Examples
-
-### Ownership & Lifetimes
-
-```rust
-// Explicit lifetime annotation — borrow lives as long as the input slice
-fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
-    if x.len() > y.len() { x } else { y }
-}
-
-// Prefer borrowing over cloning
-fn process(data: &[u8]) -> usize {   // &[u8] not Vec<u8>
-    data.iter().filter(|&&b| b != 0).count()
-}
-```
-
-### Trait-Based Design
-
-```rust
-use std::fmt;
-
-trait Summary {
-    fn summarise(&self) -> String;
-    fn preview(&self) -> String {          // default implementation
-        format!("{}...", &self.summarise()[..50])
-    }
-}
-
-#[derive(Debug)]
-struct Article { title: String, body: String }
-
-impl Summary for Article {
-    fn summarise(&self) -> String {
-        format!("{}: {}", self.title, self.body)
-    }
-}
-```
-
-### Error Handling with `thiserror`
-
-```rust
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum AppError {
-    #[error("I/O error: {0}")]
-    Io(#[from] std::io::Error),
-    #[error("parse error for value `{value}`: {reason}")]
-    Parse { value: String, reason: String },
-}
-
-// ? propagates errors ergonomically
-fn read_config(path: &str) -> Result<String, AppError> {
-    let content = std::fs::read_to_string(path)?;  // Io variant via #[from]
-    Ok(content)
-}
-```
-
-### Async / Await with Tokio
-
-```rust
-use tokio::time::{sleep, Duration};
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let result = fetch_data("https://example.com").await?;
-    println!("{result}");
-    Ok(())
-}
-
-async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
-    let body = reqwest::get(url).await?.text().await?;
-    Ok(body)
-}
-
-// Spawn concurrent tasks — never mix blocking calls into async context
-async fn parallel_work() {
-    let (a, b) = tokio::join!(
-        sleep(Duration::from_millis(100)),
-        sleep(Duration::from_millis(100)),
-    );
-}
-```
-
-### Validation Commands
-
-```bash
-cargo fmt --check                          # style check
-cargo clippy --all-targets --all-features  # lints
-cargo test                                 # unit + integration tests
-cargo test --doc                           # doctests
-cargo bench                                # criterion benchmarks (if present)
-```
-
-## Constraints
-
-### MUST DO
-- Use ownership and borrowing for memory safety
-- Minimize unsafe code (document all unsafe blocks with safety invariants)
-- Use type system for compile-time guarantees
-- Handle all errors explicitly (`Result`/`Option`)
-- Add comprehensive documentation with examples
-- Run `cargo clippy` and fix all warnings
-- Use `cargo fmt` for consistent formatting
-- Write tests including doctests
-
-### MUST NOT DO
-- Use `unwrap()` in production code (prefer `expect()` with messages)
-- Create memory leaks or dangling pointers
-- Use `unsafe` without documenting safety invariants
-- Ignore clippy warnings
-- Mix blocking and async code incorrectly
-- Skip error handling
-- Use `String` when `&str` suffices
-- Clone unnecessarily (use borrowing)
-
-## Output Templates
-
-When implementing Rust features, provide:
-1. Type definitions (structs, enums, traits)
-2. Implementation with proper ownership
-3. Error handling with custom error types
-4. Tests (unit, integration, doctests)
-5. Brief explanation of design decisions
-
-## Knowledge Reference
-
-Rust 2021, Cargo, ownership/borrowing, lifetimes, traits, generics, async/await, tokio, Result/Option, thiserror/anyhow, serde, clippy, rustfmt, cargo-test, criterion benchmarks, MIRI, unsafe Rust