tdd-claude-code 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jurgen Calleja
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# TDD Workflow for Claude Code
+
+Test-Led Development powered by [GSD](https://github.com/glittercowboy/get-shit-done).
+
+**One interface. Tests happen automatically. You don't think about methodology.**
+
+## Install
+
+```bash
+npx tdd-claude-code
+```
+
+GSD is installed automatically if missing.
+
+Options:
+```bash
+npx tdd-claude-code --global   # available in all projects
+npx tdd-claude-code --local    # this project only
+```
+
+## Usage
+
+You use `/tdd:*` commands for everything. Never touch `/gsd:*` directly.
+
+```
+/tdd:new-project          Describe your idea, get test infrastructure
+    ↓
+/tdd:discuss 1            Shape how phase 1 gets built
+/tdd:plan 1               Create task plans
+/tdd:build 1              Write tests → implement → tests pass  ← TDD happens here
+/tdd:verify 1             Human acceptance testing
+    ↓
+...repeat for each phase...
+    ↓
+/tdd:complete             Tag release
+```
+
+## What `/tdd:build` Does
+
+This is where the magic happens:
+
+1. **Red** — Spawns agents to write failing tests for each task
+2. **Verify** — Runs tests, confirms they fail (code doesn't exist yet)
+3. **Green** — Calls GSD to implement (you walk away)
+4. **Verify** — Runs tests, confirms they pass
+
+You run one command. Tests get written before code. Automatically.
+
+## Commands
+
+| Command | What It Does |
+|---------|--------------|
+| `/tdd:new-project` | Start project with test infrastructure |
+| `/tdd:discuss [N]` | Capture implementation preferences |
+| `/tdd:plan [N]` | Create task plans |
+| `/tdd:build <N>` | **Write tests → implement → verify** |
+| `/tdd:verify [N]` | Human acceptance testing |
+| `/tdd:status [N]` | Check test pass/fail |
+| `/tdd:progress` | Where am I? |
+| `/tdd:quick` | Ad-hoc task with tests |
+| `/tdd:complete` | Tag release |
+| `/tdd:new-milestone` | Start next version |
+| `/tdd:help` | Show all commands |
+
+## For Vibe Coders
+
+No existing codebase? No problem.
+
+`/tdd:new-project` detects your stack and sets up the test framework:
+
+| Stack | Framework |
+|-------|-----------|
+| Next.js / React | Vitest |
+| Node.js | Vitest |
+| Python | pytest |
+| Go | go test |
+| Ruby | RSpec |
+
+You describe what you want. Tests and code get written. You verify it works.
+
+## Why TDD?
+
+**Without TDD:**
+```
+Plan → Implement → "Does it work?" → Debug → Repeat
+```
+
+**With TDD:**
+```
+Plan → Write tests (spec) → Implement (pass tests) → Verify
+```
+
+Tests define expected behavior BEFORE code exists. Implementation has concrete pass/fail targets. Bugs surface immediately, not during manual testing.
+
+Human verification still happens — tests catch logic errors, you catch "not what I meant" issues.
+
+## Safe from GSD Updates
+
+TDD lives in `.claude/commands/tdd/`
+GSD lives in `.claude/commands/gsd/`
+
+Running `npx get-shit-done-cc@latest` only touches GSD. Your TDD commands are untouched.
+
+## License
+
+MIT

package/bin/install.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const readline = require('readline');
+
+const COMMANDS = [
+  'new-project.md',
+  'discuss.md',
+  'plan.md',
+  'build.md',
+  'verify.md',
+  'status.md',
+  'progress.md',
+  'complete.md',
+  'new-milestone.md',
+  'quick.md',
+  'help.md'
+];
+
+function getGlobalDir() {
+  const claudeConfig = process.env.CLAUDE_CONFIG_DIR || path.join(require('os').homedir(), '.claude');
+  return path.join(claudeConfig, 'commands');
+}
+
+function getLocalDir() {
+  return path.join(process.cwd(), '.claude', 'commands');
+}
+
+function checkGsd(gsdDir, installType) {
+  if (!fs.existsSync(gsdDir)) {
+    console.log('');
+    console.log(`GSD dependency not found at ${gsdDir}`);
+    console.log('TDD requires GSD to function.');
+    console.log('');
+    console.log(`Installing GSD (${installType})...`);
+    try {
+      execSync('npx --yes get-shit-done-cc@latest', { stdio: 'inherit' });
+    } catch (e) {
+      // GSD installer may exit with error but still install
+    }
+    console.log('');
+    if (!fs.existsSync(gsdDir)) {
+      console.log('GSD not found at expected location after install.');
+      console.log(`Ensure GSD is installed to: ${gsdDir}`);
+      console.log('Then re-run this installer.');
+      process.exit(1);
+    }
+    console.log('GSD installed');
+    console.log('');
+  }
+}
+
+function install(targetDir, installType) {
+  const commandsDir = path.join(targetDir, 'tdd');
+  const gsdDir = path.join(targetDir, 'gsd');
+
+  // Check GSD dependency
+  checkGsd(gsdDir, installType);
+
+  // Create directory
+  fs.mkdirSync(commandsDir, { recursive: true });
+
+  // Copy command files
+  const sourceDir = path.join(__dirname, '..');
+  for (const file of COMMANDS) {
+    const src = path.join(sourceDir, file);
+    const dest = path.join(commandsDir, file);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, dest);
+    }
+  }
+
+  console.log('');
+  console.log(`TDD commands installed to ${commandsDir}`);
+  console.log('');
+  console.log('Restart Claude Code to load new commands.');
+  console.log('');
+  console.log('Workflow:');
+  console.log('  /tdd:new-project      Start project with test infrastructure');
+  console.log('  /tdd:discuss 1        Shape implementation preferences');
+  console.log('  /tdd:plan 1           Create task plans');
+  console.log('  /tdd:build 1          Write tests -> implement -> verify');
+  console.log('  /tdd:verify 1         Human acceptance testing');
+  console.log('');
+  console.log('Run /tdd:help for full command list.');
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--global') || args.includes('-g')) {
+    console.log(`Installing globally to ${getGlobalDir()}/tdd`);
+    install(getGlobalDir(), 'global');
+    return;
+  }
+
+  if (args.includes('--local') || args.includes('-l')) {
+    console.log(`Installing locally to ${getLocalDir()}/tdd`);
+    install(getLocalDir(), 'local');
+    return;
+  }
+
+  // Interactive prompt
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.log('TDD Workflow Installer');
+  console.log('');
+  console.log('Where would you like to install?');
+  console.log('  1) Global (~/.claude/commands/tdd) - available in all projects');
+  console.log('  2) Local (./.claude/commands/tdd) - this project only');
+  console.log('');
+
+  rl.question('Choice [1/2]: ', (answer) => {
+    rl.close();
+    if (answer === '2') {
+      install(getLocalDir(), 'local');
+    } else {
+      install(getGlobalDir(), 'global');
+    }
+  });
+}
+
+main();

package/build.md

@@ -0,0 +1,292 @@
+# /tdd:build - Build a Phase (Test-First)
+
+Write failing tests, then implement to make them pass.
+
+## What This Does
+
+1. **Write failing tests** for all tasks in the phase
+2. **Verify tests fail** (Red)
+3. **Call `/gsd:execute-phase`** to implement (Green)
+4. **Verify tests pass** after execution
+
+This is the core TDD command. Tests before code, automatically.
+
+## Usage
+
+```
+/tdd:build <phase_number>
+```
+
+## Process
+
+### Step 1: Load Plans
+
+Read all `.planning/phases/{phase}-*-PLAN.md` files for this phase.
+
+### Step 2: Detect Test Framework
+
+Check what's already set up:
+- `vitest.config.*` → Vitest
+- `jest.config.*` → Jest
+- `pytest.ini` or `pyproject.toml` with pytest → pytest
+- `spec/` directory → RSpec
+- None found → Set up based on PROJECT.md stack (see framework defaults below)
+
+### Step 3: Write Tests (Spawn Test Writer Agents)
+
+For each plan, spawn an agent with this prompt:
+
+<agent_prompt>
+You are a TDD Test Writer. Write failing tests that define expected behavior BEFORE implementation.
+
+## Context
+
+<project>
+{PROJECT.md contents}
+</project>
+
+<plan>
+{Current PLAN.md contents}
+</plan>
+
+<test_framework>
+{Detected or default framework}
+</test_framework>
+
+<existing_tests>
+{List any existing test files for patterns, or "None - this is a new project"}
+</existing_tests>
+
+## Your Task
+
+For each `<task>` in the plan:
+
+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
+
+**Vitest/Jest (TypeScript):**
+```typescript
+import { describe, it, expect } from 'vitest'
+// Import from where code WILL exist
+import { login } from '../src/auth/login'
+
+describe('login', () => {
+  it('returns user object for valid credentials', async () => {
+    const result = await login('user@test.com', 'password123')
+    expect(result.user).toBeDefined()
+    expect(result.user.email).toBe('user@test.com')
+  })
+
+  it('throws AuthError for invalid password', async () => {
+    await expect(login('user@test.com', 'wrong'))
+      .rejects.toThrow('Invalid credentials')
+  })
+})
+```
+
+**pytest (Python):**
+```python
+import pytest
+# Import from where code WILL exist
+from src.auth import login
+
+def test_login_returns_user_for_valid_credentials():
+    result = login("user@test.com", "password123")
+    assert result["user"]["email"] == "user@test.com"
+
+def test_login_raises_for_invalid_password():
+    with pytest.raises(AuthError, match="Invalid credentials"):
+        login("user@test.com", "wrong")
+```
+
+## Output
+
+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`
+
+After creating each test file, run it and confirm it FAILS (not errors).
+
+## 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>
+
+### Step 4: Verify All Tests Fail (Red)
+
+Run the test suite:
+```bash
+npm test          # or vitest run, pytest, etc.
+```
+
+Check output:
+- ✅ All new tests executed (no syntax errors)
+- ✅ All new tests FAILED (not passed, not skipped)
+- ❌ If tests error on imports, add mocks and retry
+- ❌ If tests pass, something's wrong — investigate
+
+### Step 5: Create Test Summary
+
+Create `.planning/phases/{phase}-TESTS.md`:
+
+```markdown
+# Phase {N} Tests
+
+Generated: {timestamp}
+Status: ✅ All tests failing (Red)
+
+## Test Files
+
+| File | Tests | Status |
+|------|-------|--------|
+| tests/auth.test.ts | 4 | ❌ Failing |
+| tests/session.test.ts | 3 | ❌ Failing |
+
+## Test Output
+
+{test runner output showing failures}
+
+## Coverage Map
+
+| Test | Task |
+|------|------|
+| user can log in with valid credentials | 01-task-1 |
+| login rejects invalid password | 01-task-1 |
+| session persists across requests | 01-task-2 |
+```
+
+### Step 6: 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)
+
+After execution completes, run tests again:
+```bash
+npm test
+```
+
+Check output:
+- ✅ All tests PASS → Continue to verify
+- ❌ Some tests fail → Report which tasks need fixes
+
+### Step 8: Update Test Summary
+
+Update `.planning/phases/{phase}-TESTS.md`:
+
+```markdown
+Status: ✅ All tests passing (Green)
+
+## Final Test Output
+
+{test runner output showing all pass}
+```
+
+## Framework Defaults (for new projects)
+
+If no test framework detected, set up based on PROJECT.md:
+
+| Stack in PROJECT.md | Framework | Setup |
+|---------------------|-----------|-------|
+| Next.js, React, Vite | Vitest | `npm install -D vitest`, create `vitest.config.ts` |
+| Node.js, Express | Vitest | `npm install -D vitest`, create `vitest.config.ts` |
+| Python, FastAPI, Flask | pytest | `pip install pytest`, create `pytest.ini` |
+| Go | go test | Built-in, create `*_test.go` files |
+| Ruby, Rails | RSpec | `gem install rspec`, `rspec --init` |
+
+Default Vitest config:
+```typescript
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node', // or 'jsdom' for React
+  },
+})
+```
+
+Default pytest.ini:
+```ini
+[pytest]
+testpaths = tests
+python_files = test_*.py
+python_functions = test_*
+```
+
+## Example Run
+
+```
+User: /tdd:build 1
+
+Claude: Loading phase 1 plans...
+Found 2 plans:
+- 01-01-PLAN.md: User authentication
+- 01-02-PLAN.md: Session management
+
+Checking test framework... Vitest detected.
+
+Writing tests for 01-01-PLAN.md...
+Created: tests/auth/login.test.ts (4 tests)
+Created: tests/auth/logout.test.ts (2 tests)
+
+Writing tests for 01-02-PLAN.md...
+Created: tests/session/session.test.ts (5 tests)
+
+Running tests...
+❌ 11 tests failing (expected - no implementation yet)
+
+Created 01-TESTS.md
+
+Executing implementation via GSD...
+[GSD execute-phase output]
+
+Running tests again...
+✅ 11 tests passing
+
+Phase 1 complete. Ready for /tdd:verify 1
+```
+
+## Error Recovery
+
+**Tests error instead of fail:**
+- Missing imports → Add mocks for dependencies
+- Syntax errors → Fix test code
+- Framework issues → Check config
+
+**Tests pass before implementation:**
+- Code already exists? Check if reimplementing
+- Tests too weak? Strengthen assertions
+- Wrong file paths? Check imports
+
+**Some tests fail after implementation:**
+- Report specific failures
+- Suggest running `/tdd:build {phase}` again to retry
+- Or manually fix and run `/tdd:status` to verify

package/complete.md

@@ -0,0 +1,23 @@
+# /tdd:complete - Complete Milestone
+
+Archive current milestone and tag the release.
+
+## What This Does
+
+1. **Verify all tests pass** for all phases
+2. **Call `/gsd:complete-milestone`**
+
+## Usage
+
+```
+/tdd:complete
+```
+
+## Process
+
+Before completing:
+- Runs full test suite
+- If any failures → Block completion, show what needs fixing
+- If all pass → Proceed with GSD milestone completion
+
+This ensures you don't tag a release with failing tests.

package/discuss.md

@@ -0,0 +1,21 @@
+# /tdd:discuss - Discuss Phase Implementation
+
+Capture your implementation preferences before planning.
+
+## What This Does
+
+Calls `/gsd:discuss-phase` — no TDD-specific logic needed here.
+
+## Usage
+
+```
+/tdd:discuss [phase_number]
+```
+
+## Example
+
+```
+/tdd:discuss 1
+```
+
+This is where you shape HOW the phase gets built — layout preferences, interaction patterns, error handling approaches, etc. The output feeds into planning and test writing.

package/help.md

@@ -0,0 +1,95 @@
+# /tdd:help - Test-Led Development Commands
+
+TDD-first workflow powered by GSD. You use `/tdd:*` for everything — tests happen automatically.
+
+## Commands
+
+### Core Workflow
+
+| Command | What It Does |
+|---------|--------------|
+| `/tdd:new-project` | Start new project with test infrastructure |
+| `/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** |
+| `/tdd:verify [N]` | Human acceptance testing |
+
+### Navigation
+
+| Command | What It Does |
+|---------|--------------|
+| `/tdd:progress` | Where am I? What's next? |
+| `/tdd:status [N]` | Check test pass/fail counts |
+| `/tdd:help` | Show this help |
+
+### Milestones
+
+| Command | What It Does |
+|---------|--------------|
+| `/tdd:complete` | Archive milestone, tag release |
+| `/tdd:new-milestone [name]` | Start next version |
+
+### Quick Tasks
+
+| Command | What It Does |
+|---------|--------------|
+| `/tdd:quick` | Ad-hoc task with test-first flow |
+
+## Workflow
+
+```
+/tdd:new-project          Describe your idea, set up project + tests
+    ↓
+/tdd:discuss 1            Shape how phase 1 gets built
+/tdd:plan 1               Create task plans
+/tdd:build 1              Write tests → implement → tests pass
+/tdd:verify 1             Human acceptance testing
+    ↓
+/tdd:discuss 2            Repeat for each phase...
+/tdd:plan 2
+/tdd:build 2
+/tdd:verify 2
+    ↓
+/tdd:complete             Tag release
+/tdd:new-milestone        Start v2
+```
+
+## What Happens in `/tdd:build`
+
+This is where TDD happens:
+
+1. **Red** — Write failing tests for each task in the plan
+2. **Verify** — Run tests, confirm they fail
+3. **Green** — Implement code (via GSD execute-phase)
+4. **Verify** — Run tests, confirm they pass
+
+You don't think about it. Just run `/tdd:build` and tests happen before code.
+
+## Philosophy
+
+**Tests define behavior. Implementation makes tests pass.**
+
+- Tests are written BEFORE code exists
+- Tests are the spec, not an afterthought
+- Human verification still happens at the end
+- You never invoke GSD directly — TDD wraps it
+
+## GSD Under the Hood
+
+TDD commands call GSD internally:
+
+| TDD Command | Calls |
+|-------------|-------|
+| `/tdd:new-project` | `/gsd:new-project` + test setup |
+| `/tdd:discuss` | `/gsd:discuss-phase` |
+| `/tdd:plan` | `/gsd:plan-phase` |
+| `/tdd:build` | write tests + `/gsd:execute-phase` |
+| `/tdd:verify` | test check + `/gsd:verify-work` |
+
+GSD does the planning and execution. TDD ensures tests come first.
+
+## Installation
+
+Lives in `.claude/commands/tdd/` — separate from GSD.
+
+GSD updates only touch `.claude/commands/gsd/`. Your TDD commands survive updates.

package/install.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+# Install TDD workflow for Claude Code (wraps GSD)
+# Usage: ./install.sh [--global | --local]
+
+set -e
+
+# Check for GSD dependency and install if missing
+check_gsd() {
+    local gsd_dir="$1"
+    local install_type="$2"
+    if [[ ! -d "$gsd_dir" ]]; then
+        echo ""
+        echo "GSD dependency not found at $gsd_dir"
+        echo "TDD requires GSD to function."
+        echo ""
+        echo "Installing GSD ($install_type)..."
+        npx --yes get-shit-done-cc@latest
+        echo ""
+        if [[ ! -d "$gsd_dir" ]]; then
+            echo "❌ GSD not found at expected location after install."
+            echo "   Ensure GSD is installed to: $gsd_dir"
+            echo "   Then re-run this installer."
+            exit 1
+        fi
+        echo "✅ GSD installed"
+        echo ""
+    fi
+}
+
+# Determine install location
+if [[ "$1" == "--global" || "$1" == "-g" ]]; then
+    INSTALL_DIR="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/commands/tdd"
+    echo "Installing globally to $INSTALL_DIR"
+elif [[ "$1" == "--local" || "$1" == "-l" ]]; then
+    INSTALL_DIR="./.claude/commands/tdd"
+    echo "Installing locally to $INSTALL_DIR"
+else
+    echo "TDD Workflow Installer"
+    echo ""
+    echo "Where would you like to install?"
+    echo "  1) Global (~/.claude/commands/tdd) - available in all projects"
+    echo "  2) Local (./.claude/commands/tdd) - this project only"
+    echo ""
+    read -p "Choice [1/2]: " choice
+    
+    if [[ "$choice" == "2" ]]; then
+        INSTALL_DIR="./.claude/commands/tdd"
+    else
+        INSTALL_DIR="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/commands/tdd"
+    fi
+fi
+
+# Derive GSD location (sibling to tdd directory)
+GSD_DIR="${INSTALL_DIR%/tdd}/gsd"
+
+# Determine install type for messaging
+if [[ "$INSTALL_DIR" == *"$HOME"* ]] || [[ "$INSTALL_DIR" == *"${CLAUDE_CONFIG_DIR:-}"* ]]; then
+    INSTALL_TYPE="global"
+else
+    INSTALL_TYPE="local"
+fi
+
+# Check and install GSD if needed
+check_gsd "$GSD_DIR" "$INSTALL_TYPE"
+
+# Create directory
+mkdir -p "$INSTALL_DIR"
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Copy command files
+cp "$SCRIPT_DIR/new-project.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/discuss.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/plan.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/build.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/verify.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/status.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/progress.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/complete.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/new-milestone.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/quick.md" "$INSTALL_DIR/"
+cp "$SCRIPT_DIR/help.md" "$INSTALL_DIR/"
+
+echo ""
+echo "✅ TDD commands installed to $INSTALL_DIR"
+echo ""
+echo "Restart Claude Code to load new commands."
+echo ""
+echo "Workflow:"
+echo "  /tdd:new-project      Start project with test infrastructure"
+echo "  /tdd:discuss 1        Shape implementation preferences"
+echo "  /tdd:plan 1           Create task plans"
+echo "  /tdd:build 1          Write tests → implement → verify"
+echo "  /tdd:verify 1         Human acceptance testing"
+echo ""
+echo "Run /tdd:help for full command list."

package/new-milestone.md

@@ -0,0 +1,21 @@
+# /tdd:new-milestone - Start Next Version
+
+Begin the next milestone after completing the previous one.
+
+## What This Does
+
+Calls `/gsd:new-milestone` — same flow as new-project but for an existing codebase.
+
+## Usage
+
+```
+/tdd:new-milestone [name]
+```
+
+## Example
+
+```
+/tdd:new-milestone v2.0
+```
+
+Starts the question → research → requirements → roadmap flow for your next version.

package/new-project.md

@@ -0,0 +1,56 @@
+# /tdd:new-project - Start a New Project
+
+Initialize a new project with test-led development.
+
+## What This Does
+
+Calls `/gsd:new-project` with TDD conventions automatically added to PROJECT.md.
+
+## Process
+
+1. **Run GSD new-project flow**
+   - Questions → Research → Requirements → Roadmap
+   
+2. **After PROJECT.md is created, append TDD conventions:**
+
+```markdown
+## Development Methodology: Test-Led Development
+
+This project uses TDD. All 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.
+```
+
+3. **Detect or set up test framework** based on stack chosen during setup:
+
+| Stack | Framework | Config |
+|-------|-----------|--------|
+| Next.js / React | Vitest | `vitest.config.ts` |
+| Node.js | Vitest or Jest | `vitest.config.ts` |
+| Python | pytest | `pytest.ini` or `pyproject.toml` |
+| Go | go test | (built-in) |
+| Ruby | RSpec | `.rspec`, `spec/spec_helper.rb` |
+
+4. **Create test directory structure** if it doesn't exist:
+   - `tests/` or `__tests__/` or `spec/` depending on convention
+   - Example test file showing project patterns
+
+5. **Add test script** to package.json / pyproject.toml / Makefile:
+   ```json
+   "scripts": {
+     "test": "vitest run",
+     "test:watch": "vitest"
+   }
+   ```
+
+## Usage
+
+```
+/tdd:new-project
+```
+
+Same interactive flow as GSD, but you end up with test infrastructure ready to go.

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "tdd-claude-code",
+  "version": "0.1.0",
+  "description": "TDD workflow for Claude Code - wraps GSD",
+  "bin": {
+    "tdd-claude-code": "./bin/install.js"
+  },
+  "files": [
+    "bin/",
+    "*.md",
+    "install.sh"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jurgencalleja/tdd.git"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "tdd",
+    "test-driven-development",
+    "gsd"
+  ],
+  "author": "Jurgen Calleja",
+  "license": "MIT"
+}

package/plan.md

@@ -0,0 +1,23 @@
+# /tdd:plan - Plan a Phase
+
+Research and create implementation plans for a phase.
+
+## What This Does
+
+Calls `/gsd:plan-phase` — no TDD-specific logic needed here.
+
+Plans are created as usual. Tests get written when you run `/tdd:build`.
+
+## Usage
+
+```
+/tdd:plan [phase_number]
+```
+
+## Example
+
+```
+/tdd:plan 1
+```
+
+Creates `{phase}-RESEARCH.md` and `{phase}-*-PLAN.md` files with task breakdowns.

package/progress.md

@@ -0,0 +1,28 @@
+# /tdd:progress - Where Am I?
+
+Check current project status and what's next.
+
+## What This Does
+
+Calls `/gsd:progress` plus shows test status.
+
+## Usage
+
+```
+/tdd:progress
+```
+
+## Output Example
+
+```
+Project: My App
+Milestone: v1.0
+
+Phase 1: User Auth       ✅ Complete (tests: 11/11 passing)
+Phase 2: Dashboard       🔄 In Progress (tests: 6/12 passing)
+Phase 3: Settings        ⏳ Not Started
+
+Current: Phase 2, implementing task 3 of 5
+
+Next action: /tdd:build 2 (continue implementation)
+```

package/quick.md

@@ -0,0 +1,52 @@
+# /tdd:quick - Quick Task with Tests
+
+For ad-hoc tasks that don't need full phase planning, but still deserve tests.
+
+## What This Does
+
+1. **Ask what you want to do**
+2. **Write a failing test** for it
+3. **Implement** to pass the test
+4. **Verify** test passes
+
+Lighter weight than `/tdd:build`, but still test-first.
+
+## Usage
+
+```
+/tdd:quick
+```
+
+## Example
+
+```
+User: /tdd:quick
+
+Claude: What do you want to do?
+
+User: Add a dark mode toggle to settings
+
+Claude: Writing test...
+
+Created: tests/settings/dark-mode.test.ts
+- toggles dark mode on click
+- persists preference to localStorage
+- applies dark class to document
+
+Running test... ❌ Failing (expected)
+
+Implementing...
+
+Running test... ✅ Passing
+
+Done. Dark mode toggle added with test coverage.
+```
+
+## When to Use
+
+- Bug fixes
+- Small features
+- Config changes
+- One-off tasks
+
+For anything bigger, use the full flow: `/tdd:plan` → `/tdd:build` → `/tdd:verify`

package/status.md

@@ -0,0 +1,65 @@
+# /tdd:status - Check Test Status
+
+Quick check on test status for current or specified phase.
+
+## Usage
+
+```
+/tdd:status [phase_number]
+```
+
+If no phase specified, shows overall test status.
+
+## Process
+
+1. **Detect test framework** (Vitest, Jest, pytest, etc.)
+2. **Run the test suite**
+3. **Report results** with next action
+
+## Output Examples
+
+**All tests passing:**
+```
+Test Status
+───────────
+✅ 18 passing, 0 failing, 0 errors
+
+Ready for: /tdd:verify
+```
+
+**Some failing:**
+```
+Test Status
+───────────
+🔄 12 passing, 6 failing, 0 errors
+
+Failing:
+• tests/auth.test.ts: login rejects invalid password
+• tests/auth.test.ts: login returns httpOnly cookie
+• tests/session.test.ts: session expires after timeout
+...
+
+Action: Fix implementation or run /tdd:build to retry
+```
+
+**Tests erroring:**
+```
+Test Status
+───────────
+⚠️ 10 passing, 0 failing, 3 errors
+
+Errors:
+• tests/auth.test.ts:45 - Cannot find module '../src/auth'
+• tests/session.test.ts:12 - TypeError: x is not a function
+
+Action: Fix test errors before continuing
+```
+
+**No tests found:**
+```
+Test Status
+───────────
+No tests found.
+
+Run /tdd:build to write tests and implement.
+```

package/verify.md

@@ -0,0 +1,65 @@
+# /tdd:verify - Human Acceptance Testing
+
+Verify the phase works as expected — with your own eyes.
+
+## What This Does
+
+1. **Check tests pass** — Quick sanity check before human testing
+2. **Call `/gsd:verify-work`** — Walk through testable deliverables
+
+## Usage
+
+```
+/tdd:verify [phase_number]
+```
+
+## Process
+
+### Step 1: Run Tests
+
+```bash
+npm test   # or pytest, go test, etc.
+```
+
+- ✅ All pass → Continue to human verification
+- ❌ Some fail → Report failures, suggest `/tdd:build {N}` to fix
+
+### Step 2: Human Verification
+
+Call `/gsd:verify-work {phase_number}`
+
+GSD walks you through each deliverable:
+- "Can you log in with email?" → Yes / No / Describe issue
+- "Does the dashboard load?" → Yes / No / Describe issue
+
+Issues get diagnosed and fix plans created.
+
+## Why Both?
+
+**Tests verify code works.**
+**You verify it works the way you wanted.**
+
+Tests catch regressions and logic errors. Human verification catches "technically correct but not what I meant" issues — wrong layout, confusing flow, missing edge case you forgot to specify.
+
+Both matter.
+
+## Example
+
+```
+User: /tdd:verify 1
+
+Claude: Running tests...
+✅ 11 tests passing
+
+Starting human verification...
+
+Phase 1 delivered:
+1. User login with email/password
+2. Session persistence
+3. Logout functionality
+
+Let's verify each:
+
+[1/3] Can you log in with a valid email and password?
+→ 
+```