tdd-claude-code 0.2.0 → 0.4.0

package/README.md

@@ -27,7 +27,10 @@ npx tdd-claude-code --local    # this project only
 You use `/tdd:*` commands for everything. Never touch `/gsd:*` directly.
 
 ```
-/tdd:new-project          Describe your idea, get test infrastructure
+/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
@@ -55,6 +58,8 @@ You run one command. Tests get written before code. Automatically.
 | Command | What It Does |
 |---------|--------------|
 | `/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,10 +26,12 @@ ${c.cyan}  ████████╗██████╗ ██████
      ╚═╝   ╚═════╝ ╚═════╝${c.reset}
 `;
 
-const VERSION = '0.2.0';
+const VERSION = '0.4.0';
 
 const COMMANDS = [
   'new-project.md',
+  'init.md',
+  'coverage.md',
   'discuss.md',
   'plan.md',
   'build.md',

package/coverage.md

@@ -0,0 +1,155 @@
+# /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":**
+
+For each file, write tests that capture current behavior:
+1. Read the source file
+2. Identify exported functions/classes
+3. Write tests for each public interface
+4. Run tests to verify they pass (code already exists)
+5. Mark item complete in 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

@@ -4,11 +4,18 @@ TDD-first workflow powered by GSD. You use `/tdd:*` for everything — tests hap
 
 ## Commands
 
-### Core Workflow
+### Getting Started
 
 | Command | What It Does |
 |---------|--------------|
 | `/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
+
+| Command | What It Does |
+|---------|--------------|
 | `/tdd:discuss [N]` | Capture implementation preferences for phase N |
 | `/tdd:plan [N]` | Research and create task plans for phase N |
 | `/tdd:build <N>` | **Write tests → implement → verify tests pass** |
@@ -38,7 +45,10 @@ TDD-first workflow powered by GSD. You use `/tdd:*` for everything — tests hap
 ## Workflow
 
 ```
-/tdd:new-project          Describe your idea, set up project + tests
+/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
@@ -81,6 +91,8 @@ TDD commands call GSD internally:
 | TDD Command | Calls |
 |-------------|-------|
 | `/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

@@ -0,0 +1,219 @@
+# /tdd:init - Initialize TDD in Existing Project
+
+Add TDD workflow to an existing codebase. Analyzes what you have, identifies gaps, and offers to write tests for existing code.
+
+## When to Use
+
+- You have existing code without tests
+- You have existing code with some tests
+- 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
+
+### 1. Scan for Existing Code
+
+Check for source files:
+- `src/`, `lib/`, `app/`, `pkg/`, or root-level code files
+- `package.json`, `pyproject.toml`, `go.mod`, `Gemfile`, `Cargo.toml`
+
+If no code found, suggest running `/tdd:new-project` instead.
+
+### 2. Detect Stack
+
+| Indicator | Stack |
+|-----------|-------|
+| `package.json` + React/Next deps | Next.js / React |
+| `package.json` (no framework) | Node.js |
+| `pyproject.toml` / `requirements.txt` | Python |
+| `go.mod` | Go |
+| `Gemfile` | Ruby |
+| `Cargo.toml` | Rust |
+
+### 3. Scan for Existing Tests
+
+Look for test indicators:
+
+**Directories:**
+- `tests/`, `test/`, `__tests__/`, `spec/`
+
+**Files:**
+- `*_test.py`, `test_*.py`
+- `*.test.ts`, `*.test.js`, `*.spec.ts`, `*.spec.js`
+- `*_test.go`
+- `*_spec.rb`
+
+**Config files:**
+- `vitest.config.*`, `jest.config.*`, `pytest.ini`, `pyproject.toml` [tool.pytest]
+- `.rspec`, `spec/spec_helper.rb`
+
+### 4. Set Up Test Framework (if missing)
+
+If no tests found, set up based on detected stack:
+
+| Stack | Framework | Setup |
+|-------|-----------|-------|
+| Next.js / React | Vitest | `npm install -D vitest @testing-library/react` |
+| Node.js | Vitest | `npm install -D vitest` |
+| Python | pytest | `pip install pytest` or add to pyproject.toml |
+| Go | go test | Built-in, no setup needed |
+| Ruby | RSpec | `gem install rspec && rspec --init` |
+| Rust | cargo test | Built-in, no setup needed |
+
+Create config file and test directory structure.
+
+Add test scripts to package.json / pyproject.toml / Makefile:
+```json
+"scripts": {
+  "test": "vitest run",
+  "test:watch": "vitest"
+}
+```
+
+### 5. If Tests Already Exist
+
+- Skip framework setup
+- Note existing test patterns for consistency
+- Report: "Found existing test framework: [vitest/jest/pytest/etc]"
+- Report: "Found X existing test files"
+
+### 6. Analyze Existing Code Structure
+
+Scan the codebase and generate summary:
+- Main directories and their purpose
+- Key modules/components identified
+- Entry points (main files, API routes, etc.)
+- Dependencies and their roles
+
+### 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:
+
+```markdown
+# [Project Name]
+
+## Overview
+[Inferred from code structure and README if present]
+
+## Tech Stack
+- [Detected stack]
+- [Key dependencies]
+
+## Project Structure
+[Generated from scan]
+
+## Development Methodology: Test-Led Development
+
+This project uses TDD. All new implementation follows Red -> Green -> Refactor:
+
+1. **Red**: Write failing tests that define expected behavior
+2. **Green**: Write minimum code to make tests pass
+3. **Refactor**: Clean up while keeping tests green
+
+Tests are written BEFORE implementation, not after.
+
+## Test Framework
+- Framework: [detected or installed]
+- Run tests: `[test command]`
+- Test directory: `[path]`
+```
+
+If PROJECT.md exists, append the TDD section only.
+
+### 10. Report Summary
+
+```
+TDD initialized for [project name]
+
+Stack: [detected]
+Test framework: [framework] (existing/newly configured)
+Test directory: [path]
+Existing tests: [count] files
+Untested files: [count] identified
+
+Next steps:
+- 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
+```
+
+## Usage
+
+```
+/tdd:init
+```
+
+No arguments needed. Auto-detects everything.

package/package.json

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