@tinkcarlos/skillora 0.2.0

package/.claude/skills/test-driven-development/SKILL.md

@@ -0,0 +1,246 @@
+---
+name: test-driven-development
+description: |
+  Strict TDD workflow with RED-GREEN-REFACTOR cycle.
+
+  Use when:
+  - Writing new features or functionality
+  - Fixing bugs (write failing test first)
+  - Refactoring existing code
+  - Any behavior changes
+
+  Key Features:
+  - Iron Law: NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
+  - Mandatory "Watch it fail" verification
+  - Minimal code to pass tests
+  - Frequent commits after each green
+
+  Exceptions (ask human first): Throwaway prototypes, generated code, config files.
+allowed-tools: [read, write, execute, grep, glob]
+---
+
+# Test-Driven Development (TDD)
+
+**Core Principle**: Write the test first. Watch it fail. Write minimal code to pass.
+
+## The Iron Law
+
+```
+NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
+```
+
+If you wrote code before the test? **Delete it. Start over.** No keeping it as "reference" or adapting it.
+
+## When to Use
+
+**Always:**
+- New features
+- Bug fixes
+- Refactoring
+- Behavior changes
+
+**Exceptions (ask your human partner):**
+- Throwaway prototypes
+- Generated code
+- Configuration files
+
+## The RED-GREEN-REFACTOR Cycle
+
+### 🔴 RED - Write Failing Test
+
+1. **One behavior per test** - Test exactly one thing
+2. **Clear descriptive name** - `test_user_can_login_with_valid_credentials`
+3. **Use real code** - Mocks only if unavoidable
+4. **Arrange-Act-Assert** pattern
+
+```python
+def test_calculate_total_with_discount():
+    # Arrange
+    cart = Cart()
+    cart.add_item(Item(price=100))
+
+    # Act
+    total = cart.calculate_total(discount=0.1)
+
+    # Assert
+    assert total == 90
+```
+
+### ⚠️ VERIFY RED - Watch It Fail
+
+**MANDATORY. NEVER SKIP.**
+
+1. Run the test
+2. Confirm it **fails** (not errors)
+3. Verify it fails for the **expected reason**
+
+```bash
+# Run single test
+pytest tests/test_cart.py::test_calculate_total_with_discount -v
+
+# Expected output: FAILED (not ERROR)
+# Expected reason: "AttributeError: 'Cart' has no attribute 'calculate_total'"
+```
+
+**If test passes immediately**: Your test is wrong. Delete and rewrite.
+
+### 🟢 GREEN - Minimal Code
+
+Write the **simplest code** to make the test pass.
+
+**DO:**
+- Return hardcoded values if that passes
+- Write the most naive implementation
+- Focus only on passing this one test
+
+**DON'T:**
+- Add features not tested
+- Over-engineer
+- "Improve" while implementing
+
+```python
+# Minimal implementation to pass
+def calculate_total(self, discount=0):
+    total = sum(item.price for item in self.items)
+    return total * (1 - discount)
+```
+
+### ⚠️ VERIFY GREEN - Watch It Pass
+
+**MANDATORY.**
+
+1. Run the test
+2. Confirm it **passes**
+3. Confirm **all other tests** still pass
+4. Output is **clean** (no warnings)
+
+```bash
+# Run all tests
+pytest -v
+
+# Expected: ALL PASSED
+```
+
+### 🔵 REFACTOR - Clean Up
+
+**Only after green.** Keep tests green throughout.
+
+**DO:**
+- Remove duplication
+- Improve names
+- Extract helpers
+- Simplify logic
+
+**DON'T:**
+- Add new behavior
+- Change what tests verify
+- Skip running tests
+
+```bash
+# After each refactor change
+pytest -v  # Must stay green
+```
+
+### 📝 COMMIT - Lock In Progress
+
+After each successful RED-GREEN-REFACTOR cycle:
+
+```bash
+git add .
+git commit -m "feat: add discount calculation to cart"
+```
+
+## Common Rationalizations (All Invalid)
+
+| Rationalization | Why It's Wrong |
+|-----------------|----------------|
+| "Too simple to test" | Simple code breaks too |
+| "I'll test after" | Tests passing immediately prove nothing |
+| "Already manually tested" | Ad-hoc ≠ systematic |
+| "Deleting X hours is wasteful" | Sunk cost fallacy |
+| "Just this once" | Slippery slope |
+| "Keep as reference" | Reference becomes production |
+
+## Red Flags - STOP and Start Over
+
+- ❌ Code written before test
+- ❌ Test passes immediately
+- ❌ Rationalizing "just this once"
+- ❌ "Keep as reference"
+- ❌ Multiple behaviors in one test
+- ❌ Skipping "watch it fail" step
+
+## 🔴 Failure Escalation Protocol
+
+| 失败次数 | 动作 |
+|---------|------|
+| 1次 | 重试，检查测试逻辑 |
+| 2次 | 审视设计假设 |
+| 3次 | **停止！质疑架构/设计** |
+
+**3次测试失败后必须:**
+1. 暂停当前实现
+2. 重新审视需求理解
+3. 考虑是否需要重新设计
+4. 询问用户是否继续
+
+## 🔴 Mandatory code-review
+
+After completing TDD cycle, **MUST** invoke `code-review` skill before declaring done.
+
+## Quick Reference
+
+| Phase | Action | Verify |
+|-------|--------|--------|
+| 🔴 RED | Write failing test | Test FAILS for expected reason |
+| 🟢 GREEN | Write minimal code | Test PASSES, all tests pass |
+| 🔵 REFACTOR | Clean up code | All tests still pass |
+| 📝 COMMIT | Lock in progress | Clean commit |
+
+## Verification Checklist
+
+Before declaring "done":
+
+- [ ] Every function has a test
+- [ ] Watched each test fail first
+- [ ] Wrote minimal code to pass
+- [ ] All tests pass with clean output
+- [ ] Edge cases covered
+- [ ] Committed after each cycle
+
+## Output Contract
+
+```markdown
+## TDD Session Report
+
+### Tests Written
+| Test | Purpose | Verified Fail | Verified Pass |
+|------|---------|---------------|---------------|
+| test_xxx | ... | ✅ | ✅ |
+
+### Implementation
+[What was implemented]
+
+### Commits
+- `abc123` - feat: add X
+- `def456` - feat: add Y
+
+### Verification
+- [ ] All tests pass
+- [ ] No skipped "watch it fail" steps
+- [ ] Minimal code written
+```
+
+## The Final Rule
+
+> "Production code exists → test exists and failed first. Otherwise → not TDD."
+
+---
+
+## Reference Navigation
+
+| Situation | Read This |
+|-----------|-----------|
+| Common testing mistakes | `references/testing-anti-patterns.md` |
+| Test naming and structure | `references/testing-anti-patterns.md` |
+| Testing skills themselves | `../skill-creator/references/testing-skills-with-subagents.md` |

package/.claude/skills/test-driven-development/references/testing-anti-patterns.md

@@ -0,0 +1,192 @@
+# Testing Anti-Patterns
+
+> 来源: Superpowers 项目最佳实践
+
+## 常见测试反模式
+
+### 1. 测试后写 (Test-After)
+
+**反模式**:
+```python
+# 先写实现
+def calculate_total(items):
+    return sum(item.price for item in items)
+
+# 然后写测试
+def test_calculate_total():
+    assert calculate_total([Item(10), Item(20)]) == 30
+```
+
+**问题**: 测试立即通过，你不知道它是否测试了正确的东西。
+
+**正确做法**: 先写测试，看它失败，然后实现。
+
+### 2. 测试实现而非行为
+
+**反模式**:
+```python
+def test_uses_sum_function():
+    # 测试内部实现
+    with patch('builtins.sum') as mock_sum:
+        calculate_total([Item(10)])
+        mock_sum.assert_called_once()
+```
+
+**问题**: 实现改变时测试就会失败，即使行为正确。
+
+**正确做法**: 测试输入/输出行为。
+
+### 3. 过度 Mock
+
+**反模式**:
+```python
+def test_user_login():
+    mock_db = Mock()
+    mock_hasher = Mock()
+    mock_session = Mock()
+    mock_logger = Mock()
+    # ... 10 个 mock
+```
+
+**问题**: 测试变得脆弱，不测试真实行为。
+
+**正确做法**: 只 mock 外部依赖 (数据库、网络)，使用真实对象。
+
+### 4. 测试太多东西
+
+**反模式**:
+```python
+def test_user_registration():
+    # 测试注册
+    user = register("test@example.com", "password")
+    assert user.email == "test@example.com"
+
+    # 也测试登录
+    session = login("test@example.com", "password")
+    assert session.is_valid
+
+    # 也测试权限
+    assert user.can_access("dashboard")
+```
+
+**问题**: 一个测试失败，不知道哪个功能坏了。
+
+**正确做法**: 一个测试一个行为。
+
+### 5. 不确定性测试
+
+**反模式**:
+```python
+def test_random_selection():
+    result = select_random_item([1, 2, 3])
+    assert result in [1, 2, 3]  # 总是通过
+```
+
+**问题**: 测试不验证任何有意义的东西。
+
+**正确做法**: 使用种子或测试分布。
+
+### 6. 睡眠等待
+
+**反模式**:
+```python
+def test_async_operation():
+    start_async_task()
+    time.sleep(5)  # 希望它完成了
+    assert get_result() == expected
+```
+
+**问题**: 慢、不可靠、可能在 CI 中失败。
+
+**正确做法**: 使用轮询或回调。
+
+### 7. 测试私有方法
+
+**反模式**:
+```python
+def test_internal_helper():
+    obj = MyClass()
+    result = obj._private_helper(data)
+    assert result == expected
+```
+
+**问题**: 私有方法是实现细节，可能改变。
+
+**正确做法**: 通过公共 API 测试。
+
+### 8. 共享状态
+
+**反模式**:
+```python
+class TestUser:
+    user = None  # 共享状态
+
+    def test_create(self):
+        self.user = create_user()
+
+    def test_update(self):
+        self.user.name = "new"  # 依赖前一个测试
+```
+
+**问题**: 测试顺序依赖，难以隔离失败。
+
+**正确做法**: 每个测试独立设置。
+
+## 测试质量检查清单
+
+### 每个测试应该:
+
+- [ ] 测试一个行为
+- [ ] 有描述性名称
+- [ ] 独立运行
+- [ ] 快速执行 (< 1秒)
+- [ ] 确定性 (每次相同结果)
+
+### 测试套件应该:
+
+- [ ] 覆盖所有公共 API
+- [ ] 包含边界情况
+- [ ] 包含错误情况
+- [ ] 在 CI 中运行
+- [ ] 快速完成 (< 5分钟)
+
+## 好测试的特征
+
+| 特征 | 描述 |
+|------|------|
+| **Fast** | 毫秒级执行 |
+| **Isolated** | 不依赖其他测试 |
+| **Repeatable** | 每次相同结果 |
+| **Self-validating** | 自动判断通过/失败 |
+| **Timely** | 在代码之前写 |
+
+## 测试命名规范
+
+```python
+# 格式: test_<被测方法>_<场景>_<预期结果>
+
+def test_calculate_total_with_empty_cart_returns_zero():
+    ...
+
+def test_login_with_invalid_password_raises_error():
+    ...
+
+def test_user_can_access_own_profile():
+    ...
+```
+
+## 测试结构 (AAA)
+
+```python
+def test_example():
+    # Arrange - 设置
+    user = User(name="test")
+    cart = Cart()
+    cart.add_item(Item(price=100))
+
+    # Act - 执行
+    total = cart.calculate_total(user)
+
+    # Assert - 验证
+    assert total == 100
+```

package/.claude/skills/using-git-worktrees/SKILL.md

@@ -0,0 +1,266 @@
+---
+name: using-git-worktrees
+description: |
+  Create isolated development environments using git worktrees.
+
+  Use when:
+  - Starting a new feature after design approval
+  - Need isolated workspace for development
+  - Working on multiple features in parallel
+
+  Key Features:
+  - Isolated branch and directory
+  - Clean test baseline verification
+  - Project setup automation
+  - Easy cleanup when done
+
+  Workflow: brainstorming → using-git-worktrees → writing-plans → development
+allowed-tools: [read, write, execute, grep, glob]
+---
+
+# Using Git Worktrees
+
+**Core Principle**: Create isolated workspaces for each feature to prevent cross-contamination and enable parallel development.
+
+## 🔒 Directory Priority
+
+查找 worktree 目录的优先级:
+
+1. `.worktrees/` (项目内，推荐)
+2. `worktrees/` (项目内)
+3. `CLAUDE.md` 中指定的路径
+4. 询问用户
+
+## 🔒 Safety Verification (MANDATORY)
+
+创建 worktree 前必须验证:
+
+```bash
+# 1. 检查目录是否被 gitignore (应该被忽略)
+git check-ignore -v <worktree-path>
+
+# 2. 检查 worktree 是否已存在
+git worktree list | grep <branch-name>
+
+# 3. 检查分支是否已存在
+git branch --list <branch-name>
+```
+
+**如果目录未被 gitignore:** 警告用户，worktree 可能被意外提交
+**如果 worktree 已存在:** 使用现有 worktree 或选择新名称
+**如果分支已存在:** 询问用户是否使用现有分支
+
+## When to Use
+
+- After design approval from brainstorming
+- Before writing implementation plans
+- When starting any significant feature
+
+**Announce at start:** "I'm using the using-git-worktrees skill to set up an isolated workspace."
+
+## What is a Git Worktree?
+
+A git worktree allows you to have multiple working directories attached to the same repository, each on a different branch.
+
+```
+project/                    # Main worktree (main branch)
+project-feature-auth/       # Worktree for auth feature
+project-feature-api/        # Worktree for API feature
+```
+
+## Workflow
+
+```
+1. Create worktree with new branch
+2. Navigate to worktree
+3. Run project setup (install deps, etc.)
+4. Verify clean test baseline
+5. Start development
+6. When done: merge/PR and cleanup
+```
+
+## Creating a Worktree
+
+### Step 1: Create Worktree with New Branch
+
+```bash
+# From main project directory
+git worktree add ../project-feature-name -b feature/feature-name
+
+# Example
+git worktree add ../myapp-user-auth -b feature/user-auth
+```
+
+### Step 2: Navigate to Worktree
+
+```bash
+cd ../project-feature-name
+```
+
+### Step 3: Run Project Setup
+
+```bash
+# Node.js
+npm install
+
+# Python
+python -m venv venv
+source venv/bin/activate  # or venv\Scripts\activate on Windows
+pip install -r requirements.txt
+
+# Rust
+cargo build
+```
+
+### Step 4: Verify Clean Test Baseline
+
+**MANDATORY**: All tests must pass before starting development.
+
+```bash
+# Run tests
+npm test          # Node.js
+pytest            # Python
+cargo test        # Rust
+
+# Expected: ALL TESTS PASS
+```
+
+If tests fail:
+1. Do NOT proceed with development
+2. Fix issues in main branch first
+3. Pull changes into worktree
+
+## Worktree Commands Reference
+
+| Command | Purpose |
+|---------|---------|
+| `git worktree add <path> -b <branch>` | Create new worktree with new branch |
+| `git worktree add <path> <existing-branch>` | Create worktree for existing branch |
+| `git worktree list` | List all worktrees |
+| `git worktree remove <path>` | Remove a worktree |
+| `git worktree prune` | Clean up stale worktree references |
+
+## Naming Convention
+
+```
+<project-name>-<feature-short-name>
+
+Examples:
+- myapp-user-auth
+- myapp-api-v2
+- myapp-dashboard-redesign
+```
+
+## Keeping Worktree Updated
+
+If main branch has changes you need:
+
+```bash
+# In worktree directory
+git fetch origin
+git rebase origin/main
+
+# Or merge if you prefer
+git merge origin/main
+```
+
+## Finishing with a Worktree
+
+When feature is complete, use `/finishing-a-development-branch` skill.
+
+Quick reference:
+
+```bash
+# 1. Ensure all tests pass
+npm test
+
+# 2. Push branch
+git push -u origin feature/feature-name
+
+# 3. Create PR or merge
+# (depends on your workflow)
+
+# 4. Return to main project
+cd ../project
+
+# 5. Remove worktree
+git worktree remove ../project-feature-name
+
+# 6. Delete branch if merged
+git branch -d feature/feature-name
+```
+
+## Troubleshooting
+
+### "fatal: 'path' is already checked out"
+
+The branch is already checked out in another worktree.
+
+```bash
+# List worktrees to find where
+git worktree list
+
+# Either use that worktree or create new branch
+git worktree add ../new-path -b feature/new-branch
+```
+
+### "Worktree directory not empty"
+
+```bash
+# Remove the directory first
+rm -rf ../project-feature-name
+
+# Then create worktree
+git worktree add ../project-feature-name -b feature/name
+```
+
+### Tests fail in worktree but pass in main
+
+```bash
+# Ensure dependencies are installed
+npm install  # or pip install -r requirements.txt
+
+# Check for environment differences
+diff .env ../main-project/.env
+```
+
+## Output Contract
+
+```markdown
+## Worktree Created
+
+**Location:** `../project-feature-name`
+**Branch:** `feature/feature-name`
+
+**Setup Status:**
+- [ ] Worktree created
+- [ ] Dependencies installed
+- [ ] Tests passing (baseline verified)
+
+**Ready for:** `/writing-plans` to create implementation plan
+```
+
+## Integration with Other Skills
+
+| After | Use |
+|-------|-----|
+| `/brainstorming` | Create worktree for approved design |
+| Worktree ready | `/writing-plans` to create plan |
+| Development done | `/finishing-a-development-branch` |
+
+## Quick Start Template
+
+```bash
+# 1. Create worktree
+git worktree add ../myapp-feature-name -b feature/feature-name
+
+# 2. Setup
+cd ../myapp-feature-name
+npm install  # or equivalent
+
+# 3. Verify baseline
+npm test
+
+# 4. Ready for development!
+echo "Worktree ready. Use /writing-plans to create implementation plan."
+```