tdd-claude-code 0.3.0 → 0.4.1

package/README.md

@@ -30,6 +30,7 @@ You use `/tdd:*` commands for everything. Never touch `/gsd:*` directly.
 /tdd:new-project          New project from scratch
        OR
 /tdd:init                 Add TDD to existing codebase
+/tdd:coverage             Analyze gaps, write retro tests (optional)
     ↓
 /tdd:discuss 1            Shape how phase 1 gets built
 /tdd:plan 1               Create task plans
@@ -58,6 +59,7 @@ You run one command. Tests get written before code. Automatically.
 |---------|--------------|
 | `/tdd:new-project` | Start project with test infrastructure |
 | `/tdd:init` | Add TDD to existing codebase |
+| `/tdd:coverage` | Analyze gaps, write tests for existing code |
 | `/tdd:discuss [N]` | Capture implementation preferences |
 | `/tdd:plan [N]` | Create task plans |
 | `/tdd:build <N>` | **Write tests → implement → verify** |

package/bin/install.js

@@ -26,11 +26,12 @@ ${c.cyan}  ████████╗██████╗ ██████
      ╚═╝   ╚═════╝ ╚═════╝${c.reset}
 `;
 
-const VERSION = '0.3.0';
+const VERSION = '0.4.1';
 
 const COMMANDS = [
   'new-project.md',
   'init.md',
+  'coverage.md',
   'discuss.md',
   'plan.md',
   'build.md',

package/build.md

@@ -32,61 +32,60 @@ Check what's already set up:
 - `spec/` directory → RSpec
 - None found → Set up based on PROJECT.md stack (see framework defaults below)
 
-### Step 3: Write Tests (Spawn Test Writer Agents)
+### Step 3: Plan Tests for Each Task
 
-For each plan, spawn an agent with this prompt:
+Before writing any tests, create a test plan for each task in the phase.
 
-<agent_prompt>
-You are a TDD Test Writer. Write failing tests that define expected behavior BEFORE implementation.
+For each task in the plan:
 
-## Context
+1. **Read the task** — understand what behavior is being specified
+2. **Identify test cases:**
+   - Happy path (expected inputs → expected outputs)
+   - Edge cases mentioned in `<action>`
+   - Error conditions from `<verify>`
+3. **Create test plan entry**
 
-<project>
-{PROJECT.md contents}
-</project>
+Create `.planning/phases/{phase}-TEST-PLAN.md`:
 
-<plan>
-{Current PLAN.md contents}
-</plan>
+```markdown
+# Phase {N} Test Plan
 
-<test_framework>
-{Detected or default framework}
-</test_framework>
+## Task: {task-id} - {task-title}
 
-<existing_tests>
-{List any existing test files for patterns, or "None - this is a new project"}
-</existing_tests>
+### File: tests/{feature}.test.ts
 
-## Your Task
+| Test | Type | Expected Result |
+|------|------|-----------------|
+| user can log in with valid credentials | happy path | returns user object |
+| login rejects invalid password | error | throws AuthError |
+| login rejects empty email | edge case | throws ValidationError |
 
-For each `<task>` in the plan:
+### Dependencies to mock:
+- database connection
+- email service
 
-1. **Understand the task** — What behavior is being specified?
+---
 
-2. **Write test file(s)** that cover:
-   - Happy path (expected inputs → expected outputs)
-   - Edge cases mentioned in `<action>`
-   - Error conditions from `<verify>`
-   
-3. **Make tests runnable NOW** — even though implementation doesn't exist:
-   - Import from where the code WILL be (path in `<files>`)
-   - Tests should FAIL, not ERROR from missing imports
-   - Use mocks/stubs where needed for dependencies
-
-4. **Use clear test names** that describe expected behavior:
-   ```
-   ✓ "user can log in with valid credentials"
-   ✓ "login rejects invalid password with 401"
-   ✓ "login returns httpOnly cookie on success"
-   ✗ "test login" (too vague)
-   ```
-
-## Test File Patterns
+## Task: {task-id-2} - {task-title-2}
+...
+```
+
+### Step 4: Write Tests One Task at a Time
+
+**For each task in the test plan, sequentially:**
+
+#### 4a. Write test file for this task
+
+Follow the project's test patterns. Test names should describe expected behavior:
+```
+✓ "user can log in with valid credentials"
+✓ "login rejects invalid password with 401"
+✗ "test login" (too vague)
+```
 
 **Vitest/Jest (TypeScript):**
 ```typescript
 import { describe, it, expect } from 'vitest'
-// Import from where code WILL exist
 import { login } from '../src/auth/login'
 
 describe('login', () => {
@@ -106,7 +105,6 @@ describe('login', () => {
 **pytest (Python):**
 ```python
 import pytest
-# Import from where code WILL exist
 from src.auth import login
 
 def test_login_returns_user_for_valid_credentials():
@@ -118,28 +116,40 @@ def test_login_raises_for_invalid_password():
         login("user@test.com", "wrong")
 ```
 
-## Output
+#### 4b. Run this test file
+
+```bash
+npm test -- tests/auth/login.test.ts   # vitest
+pytest tests/test_login.py              # pytest
+```
+
+Verify:
+- ✅ Tests execute (no syntax errors)
+- ✅ Tests FAIL (not pass, not skip)
+- ❌ If import errors, add mocks/stubs and retry
+
+#### 4c. Commit this test file
 
-Create test files following the project's structure. Common locations:
-- `tests/{feature}.test.ts`
-- `src/{feature}/__tests__/{feature}.test.ts`
-- `tests/test_{feature}.py`
-- `spec/{feature}_spec.rb`
+```bash
+git add tests/auth/login.test.ts
+git commit -m "test: add login tests (red) - phase {N}"
+```
 
-After creating each test file, run it and confirm it FAILS (not errors).
+#### 4d. Move to next task
 
-## Critical Rules
+Repeat 4a-4c for each task in the test plan.
 
+**Critical Rules:**
 - Tests must be **syntactically valid** and **runnable**
 - Tests must **FAIL** because code doesn't exist yet
 - Tests must NOT **ERROR** from import issues — mock if needed
 - Do NOT write any implementation code
 - Do NOT skip or stub out the actual assertions
-</agent_prompt>
+- **One task at a time, verify, commit, then next**
 
-### Step 4: Verify All Tests Fail (Red)
+### Step 5: Verify All Tests Fail (Red)
 
-Run the test suite:
+Run the full test suite:
 ```bash
 npm test          # or vitest run, pytest, etc.
 ```
@@ -150,7 +160,7 @@ Check output:
 - ❌ If tests error on imports, add mocks and retry
 - ❌ If tests pass, something's wrong — investigate
 
-### Step 5: Create Test Summary
+### Step 6: Create Test Summary
 
 Create `.planning/phases/{phase}-TESTS.md`:
 
@@ -180,13 +190,13 @@ Status: ✅ All tests failing (Red)
 | session persists across requests | 01-task-2 |
 ```
 
-### Step 6: Execute Implementation (Green)
+### Step 7: Execute Implementation (Green)
 
 Call `/gsd:execute-phase {phase_number}`
 
 GSD's executor implements the code. Tests provide concrete pass/fail targets.
 
-### Step 7: Verify All Tests Pass (Green)
+### Step 8: Verify All Tests Pass (Green)
 
 After execution completes, run tests again:
 ```bash
@@ -197,7 +207,7 @@ Check output:
 - ✅ All tests PASS → Continue to verify
 - ❌ Some tests fail → Report which tasks need fixes
 
-### Step 8: Update Test Summary
+### Step 9: Update Test Summary
 
 Update `.planning/phases/{phase}-TESTS.md`:
 

package/coverage.md

@@ -0,0 +1,222 @@
+# /tdd:coverage - Analyze Test Coverage Gaps
+
+Scan existing code, identify what's untested, and offer to write retrospective tests.
+
+## When to Use
+
+- After `/tdd:init` to add tests to existing code
+- Anytime you want to improve test coverage
+- When joining a project to understand test gaps
+- After "vibe coding" a feature without tests
+
+## Process
+
+### 1. Detect Test Framework
+
+Identify the test setup:
+- Framework: vitest, jest, pytest, go test, rspec, cargo test
+- Test directory: `tests/`, `__tests__/`, `spec/`, etc.
+- Test patterns: `*.test.ts`, `*_test.py`, etc.
+
+If no test framework found, suggest running `/tdd:init` first.
+
+### 2. Scan Source Files
+
+Identify all source files:
+- `src/**/*`, `lib/**/*`, `app/**/*`, `pkg/**/*`
+- Exclude: node_modules, vendor, dist, build, .git
+
+Categorize by type:
+- **API/Routes**: files handling HTTP endpoints
+- **Services**: business logic modules
+- **Components**: UI components (React, Vue, etc.)
+- **Utils**: helper functions
+- **Models**: data structures, schemas
+- **Config**: configuration files (skip testing)
+
+### 3. Match Tests to Source
+
+For each source file, look for corresponding test:
+- `src/auth/login.ts` → `tests/auth/login.test.ts` or `src/auth/login.test.ts`
+- `lib/utils.py` → `tests/test_utils.py` or `tests/utils_test.py`
+- `pkg/api/handler.go` → `pkg/api/handler_test.go`
+
+### 4. Identify Critical Paths
+
+Flag high-priority untested code:
+- **Auth**: login, logout, session, token, password, oauth
+- **Payments**: payment, billing, charge, subscription, stripe, checkout
+- **Data mutations**: create, update, delete, save, remove
+- **Security**: validate, sanitize, permission, role, access
+
+### 5. Present Coverage Analysis
+
+```
+Test Coverage Analysis
+
+Source files: 24
+Test files: 8
+Coverage: 33% (8/24 files have tests)
+
+Tested:
+  ✓ src/utils/format.ts (src/utils/format.test.ts)
+  ✓ src/api/health.ts (tests/api/health.test.ts)
+  ... [list all]
+
+Untested - Critical:
+  ✗ src/services/payment.ts - Stripe integration, checkout flow
+  ✗ src/api/auth.ts - login, session management
+  ✗ src/middleware/auth.ts - JWT validation
+
+Untested - High Priority:
+  ✗ src/api/users.ts - user CRUD operations
+  ✗ src/services/email.ts - transactional emails
+
+Untested - Standard:
+  ✗ src/utils/helpers.ts - utility functions
+  ✗ src/components/Header.tsx - navigation component
+  ... [list all]
+```
+
+### 6. Offer Retrospective Test Writing
+
+Ask the user:
+
+```
+Would you like to write tests for existing code?
+
+1) Yes - critical paths only (fastest)
+2) Yes - critical + high priority
+3) Yes - everything untested
+4) No - just wanted the report
+```
+
+**If tests requested:**
+
+Create `.planning/TEST-BACKLOG.md`:
+
+```markdown
+# Test Backlog
+
+Generated: [date]
+Coverage before: 33% (8/24)
+
+## Critical (auth, payments, security)
+- [ ] src/services/payment.ts - Stripe integration
+- [ ] src/api/auth.ts - login/logout flows
+- [ ] src/middleware/auth.ts - JWT validation
+
+## High Priority (data mutations, core logic)
+- [ ] src/api/users.ts - CRUD operations
+- [ ] src/services/email.ts - email sending
+
+## Standard (utils, components, helpers)
+- [ ] src/utils/helpers.ts
+- [ ] src/components/Header.tsx
+```
+
+Then ask:
+```
+Start writing tests now?
+
+1) Yes - begin with first critical item
+2) No - I'll run /tdd:build backlog later
+```
+
+**If "Yes":**
+
+Write tests using GSD-style execution — one file at a time with verification and commits.
+
+#### For each file in the backlog (sequentially):
+
+**a) Plan tests for this file**
+
+Read the source file and create test plan:
+```markdown
+## File: src/services/payment.ts
+
+### Exports:
+- createCharge(amount, customerId)
+- refundCharge(chargeId)
+- getPaymentHistory(customerId)
+
+### Test cases:
+| Function | Test | Type |
+|----------|------|------|
+| createCharge | creates charge for valid customer | happy path |
+| createCharge | rejects negative amount | edge case |
+| createCharge | handles Stripe API error | error |
+| refundCharge | refunds existing charge | happy path |
+| refundCharge | fails for invalid chargeId | error |
+```
+
+**b) Write test file**
+
+Create tests that capture current behavior:
+```typescript
+import { describe, it, expect } from 'vitest'
+import { createCharge, refundCharge } from '../src/services/payment'
+
+describe('createCharge', () => {
+  it('creates charge for valid customer', async () => {
+    const result = await createCharge(1000, 'cust_123')
+    expect(result.id).toBeDefined()
+    expect(result.amount).toBe(1000)
+  })
+
+  it('rejects negative amount', async () => {
+    await expect(createCharge(-100, 'cust_123'))
+      .rejects.toThrow()
+  })
+})
+```
+
+**c) Run tests for this file**
+
+```bash
+npm test -- tests/services/payment.test.ts
+```
+
+Verify:
+- ✅ Tests PASS (code already exists)
+- ❌ If tests fail, investigate — either test is wrong or found a bug
+
+**d) Commit this test file**
+
+```bash
+git add tests/services/payment.test.ts
+git commit -m "test: add payment service tests"
+```
+
+**e) Update backlog**
+
+Mark item complete in `.planning/TEST-BACKLOG.md`:
+```markdown
+- [x] src/services/payment.ts - payment processing logic ✅
+```
+
+**f) Move to next file**
+
+Repeat a-e for each file in the backlog.
+
+### 7. Report Summary
+
+```
+Coverage analysis complete.
+
+Before: 33% (8/24 files)
+Backlog created: .planning/TEST-BACKLOG.md
+  - Critical: 3 files
+  - High priority: 2 files
+  - Standard: 11 files
+
+Run /tdd:build backlog to start writing tests.
+```
+
+## Usage
+
+```
+/tdd:coverage
+```
+
+No arguments needed. Scans entire codebase.

package/help.md

@@ -10,6 +10,7 @@ TDD-first workflow powered by GSD. You use `/tdd:*` for everything — tests hap
 |---------|--------------|
 | `/tdd:new-project` | Start new project with test infrastructure |
 | `/tdd:init` | Add TDD to existing codebase |
+| `/tdd:coverage` | Analyze gaps, write tests for existing code |
 
 ### Core Workflow
 
@@ -47,6 +48,7 @@ TDD-first workflow powered by GSD. You use `/tdd:*` for everything — tests hap
 /tdd:new-project          New project from scratch
        OR
 /tdd:init                 Existing codebase
+/tdd:coverage             Analyze gaps, write retro tests (optional)
     ↓
 /tdd:discuss 1            Shape how phase 1 gets built
 /tdd:plan 1               Create task plans
@@ -90,6 +92,7 @@ TDD commands call GSD internally:
 |-------------|-------|
 | `/tdd:new-project` | `/gsd:new-project` + test setup |
 | `/tdd:init` | scan + test setup (no GSD call) |
+| `/tdd:coverage` | scan + write tests (no GSD call) |
 | `/tdd:discuss` | `/gsd:discuss-phase` |
 | `/tdd:plan` | `/gsd:plan-phase` |
 | `/tdd:build` | write tests + `/gsd:execute-phase` |

package/init.md

@@ -1,6 +1,6 @@
 # /tdd:init - Initialize TDD in Existing Project
 
-Add TDD workflow to an existing codebase.
+Add TDD workflow to an existing codebase. Analyzes what you have, identifies gaps, and offers to write tests for existing code.
 
 ## When to Use
 
@@ -9,6 +9,12 @@ Add TDD workflow to an existing codebase.
 - You're joining a project mid-development
 - You want to adopt TDD on a "vibe coded" project
 
+This command will:
+1. Set up test infrastructure (if missing)
+2. **Analyze your existing code** to understand what it does
+3. **Identify untested modules** and critical paths
+4. **Ask if you want retrospective tests** written for existing code
+
 For brand new projects with no code, use `/tdd:new-project` instead.
 
 ## Process
@@ -87,7 +93,72 @@ Scan the codebase and generate summary:
 - Entry points (main files, API routes, etc.)
 - Dependencies and their roles
 
-### 7. Create or Update PROJECT.md
+### 7. Identify Untested Code
+
+Compare source files against test files to identify:
+- Modules/components with no corresponding tests
+- Key functions that lack test coverage
+- Critical paths (auth, payments, data mutations) without tests
+
+Present findings:
+```
+Code Coverage Analysis:
+
+Tested:
+  ✓ src/auth/login.ts (tests/auth/login.test.ts)
+  ✓ src/utils/format.ts (tests/utils/format.test.ts)
+
+Untested:
+  ✗ src/api/users.ts - CRUD operations, no tests
+  ✗ src/services/payment.ts - payment processing, no tests
+  ✗ src/components/Dashboard.tsx - main UI, no tests
+
+Critical paths without tests: 2 (auth, payments)
+```
+
+### 8. Offer Retrospective Test Writing
+
+Ask the user:
+
+```
+Would you like to write tests for existing code?
+
+1) Yes - prioritize critical paths first
+2) Yes - write tests for everything
+3) No - only use TDD for new features going forward
+```
+
+**If option 1 or 2 selected:**
+
+Create `.planning/BACKLOG.md` with test tasks:
+
+```markdown
+# Test Backlog
+
+## Critical (write first)
+- [ ] src/services/payment.ts - payment processing logic
+- [ ] src/api/auth.ts - authentication flows
+
+## High Priority
+- [ ] src/api/users.ts - user CRUD operations
+- [ ] src/middleware/validation.ts - input validation
+
+## Standard
+- [ ] src/utils/helpers.ts - utility functions
+- [ ] src/components/Dashboard.tsx - dashboard rendering
+```
+
+Then ask:
+```
+Start writing tests now, or save backlog for later?
+
+1) Start now - begin with critical paths
+2) Later - I'll run /tdd:build backlog when ready
+```
+
+**If "Start now":** Begin writing tests for the first critical path item using Red-Green-Refactor (but code already exists, so focus on capturing current behavior).
+
+### 9. Create or Update PROJECT.md
 
 If PROJECT.md doesn't exist, create it with:
 
@@ -122,7 +193,7 @@ Tests are written BEFORE implementation, not after.
 
 If PROJECT.md exists, append the TDD section only.
 
-### 8. Report Summary
+### 10. Report Summary
 
 ```
 TDD initialized for [project name]
@@ -131,9 +202,10 @@ Stack: [detected]
 Test framework: [framework] (existing/newly configured)
 Test directory: [path]
 Existing tests: [count] files
+Untested files: [count] identified
 
 Next steps:
-- Run /tdd:status to check current test coverage
+- Run /tdd:build backlog to write tests for existing code
 - Run /tdd:discuss to plan new features with TDD
 - Run /tdd:quick for ad-hoc tasks with tests
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdd-claude-code",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "TDD workflow for Claude Code - wraps GSD",
   "bin": {
     "tdd-claude-code": "./bin/install.js"