tdd-claude-code 0.1.0 → 0.3.0

package/README.md

@@ -4,6 +4,10 @@ Test-Led Development powered by [GSD](https://github.com/glittercowboy/get-shit-
 
 **One interface. Tests happen automatically. You don't think about methodology.**
 
+<p align="center">
+  <img src="assets/terminal.svg" alt="TDD Installer" width="700">
+</p>
+
 ## Install
 
 ```bash
@@ -23,7 +27,9 @@ 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:discuss 1            Shape how phase 1 gets built
 /tdd:plan 1               Create task plans
@@ -51,6 +57,7 @@ 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:discuss [N]` | Capture implementation preferences |
 | `/tdd:plan [N]` | Create task plans |
 | `/tdd:build <N>` | **Write tests → implement → verify** |

package/bin/install.js

@@ -5,8 +5,32 @@ const path = require('path');
 const { execSync } = require('child_process');
 const readline = require('readline');
 
+// ANSI color codes
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  magenta: '\x1b[35m',
+  white: '\x1b[37m',
+};
+
+const LOGO = `
+${c.cyan}  ████████╗██████╗ ██████╗
+  ╚══██╔══╝██╔══██╗██╔══██╗
+     ██║   ██║  ██║██║  ██║
+     ██║   ██║  ██║██║  ██║
+     ██║   ██████╔╝██████╔╝
+     ╚═╝   ╚═════╝ ╚═════╝${c.reset}
+`;
+
+const VERSION = '0.3.0';
+
 const COMMANDS = [
   'new-project.md',
+  'init.md',
   'discuss.md',
   'plan.md',
   'build.md',
@@ -28,27 +52,50 @@ 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 printBanner() {
+  console.log(LOGO);
+  console.log(`  ${c.bold}TDD Workflow${c.reset} ${c.dim}v${VERSION}${c.reset}`);
+  console.log(`  ${c.white}Test-Led Development for Claude Code${c.reset}`);
+  console.log(`  ${c.dim}Powered by GSD${c.reset}`);
+  console.log('');
+}
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  ${c.green}✓${c.reset} ${msg}`);
+}
+
+function info(msg) {
+  console.log(`  ${c.cyan}→${c.reset} ${msg}`);
+}
+
+function checkGsd(localGsdDir, installType) {
+  const globalGsdDir = path.join(getGlobalDir(), 'gsd');
+
+  // GSD can be in either location - check both
+  if (fs.existsSync(localGsdDir) || fs.existsSync(globalGsdDir)) {
+    return; // GSD found
+  }
+
+  log('');
+  log(`${c.yellow}GSD not found${c.reset} - installing dependency...`);
+  log('');
+  try {
+    execSync('npx --yes get-shit-done-cc@latest', { stdio: 'inherit' });
+  } catch (e) {
+    // GSD installer may exit with error but still install
+  }
+  console.log('');
+
+  // Check both locations again after install
+  if (!fs.existsSync(localGsdDir) && !fs.existsSync(globalGsdDir)) {
+    log(`${c.yellow}GSD not found after install.${c.reset}`);
+    log('Run: npx get-shit-done-cc');
+    log('Then re-run this installer.');
+    process.exit(1);
   }
 }
 
@@ -64,62 +111,79 @@ function install(targetDir, installType) {
 
   // Copy command files
   const sourceDir = path.join(__dirname, '..');
+  let installed = 0;
   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);
+      installed++;
     }
   }
 
-  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.');
+  success(`Installed ${installed} commands to ${c.cyan}${commandsDir}${c.reset}`);
+  log('');
+  log(`${c.green}Done!${c.reset} Restart Claude Code to load commands.`);
+  log('');
+  log(`${c.bold}Workflow:${c.reset}`);
+  log(`  ${c.cyan}/tdd:new-project${c.reset}  Start project with test infrastructure`);
+  log(`  ${c.cyan}/tdd:discuss${c.reset}      Shape implementation preferences`);
+  log(`  ${c.cyan}/tdd:plan${c.reset}         Create task plans`);
+  log(`  ${c.cyan}/tdd:build${c.reset}        Write tests → implement → verify`);
+  log(`  ${c.cyan}/tdd:verify${c.reset}       Human acceptance testing`);
+  log('');
+  log(`Run ${c.cyan}/tdd:help${c.reset} for full command list.`);
+  log('');
 }
 
 async function main() {
   const args = process.argv.slice(2);
 
+  printBanner();
+
   if (args.includes('--global') || args.includes('-g')) {
-    console.log(`Installing globally to ${getGlobalDir()}/tdd`);
+    info(`Installing ${c.bold}globally${c.reset} to ~/.claude/commands/tdd`);
+    log('');
     install(getGlobalDir(), 'global');
     return;
   }
 
   if (args.includes('--local') || args.includes('-l')) {
-    console.log(`Installing locally to ${getLocalDir()}/tdd`);
+    info(`Installing ${c.bold}locally${c.reset} to ./.claude/commands/tdd`);
+    log('');
     install(getLocalDir(), 'local');
     return;
   }
 
+  // Check if non-interactive
+  if (!process.stdin.isTTY) {
+    log(`${c.yellow}Non-interactive terminal detected, defaulting to global install${c.reset}`);
+    log('');
+    install(getGlobalDir(), 'global');
+    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('');
+  log('Where would you like to install?');
+  log(`  ${c.bold}1)${c.reset} Global ${c.dim}(~/.claude/commands/tdd)${c.reset} - available in all projects`);
+  log(`  ${c.bold}2)${c.reset} Local ${c.dim}(./.claude/commands/tdd)${c.reset} - this project only`);
+  log('');
 
-  rl.question('Choice [1/2]: ', (answer) => {
+  rl.question('  Choice [1/2]: ', (answer) => {
     rl.close();
+    console.log('');
     if (answer === '2') {
+      info(`Installing ${c.bold}locally${c.reset}`);
+      log('');
       install(getLocalDir(), 'local');
     } else {
+      info(`Installing ${c.bold}globally${c.reset}`);
+      log('');
       install(getGlobalDir(), 'global');
     }
   });

package/help.md

@@ -4,11 +4,17 @@ 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 |
+
+### 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 +44,9 @@ 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:discuss 1            Shape how phase 1 gets built
 /tdd:plan 1               Create task plans
@@ -81,6 +89,7 @@ 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:discuss` | `/gsd:discuss-phase` |
 | `/tdd:plan` | `/gsd:plan-phase` |
 | `/tdd:build` | write tests + `/gsd:execute-phase` |

package/init.md

@@ -0,0 +1,147 @@
+# /tdd:init - Initialize TDD in Existing Project
+
+Add TDD workflow to an existing codebase.
+
+## 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
+
+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. 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.
+
+### 8. Report Summary
+
+```
+TDD initialized for [project name]
+
+Stack: [detected]
+Test framework: [framework] (existing/newly configured)
+Test directory: [path]
+Existing tests: [count] files
+
+Next steps:
+- Run /tdd:status to check current test coverage
+- 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.1.0",
+  "version": "0.3.0",
   "description": "TDD workflow for Claude Code - wraps GSD",
   "bin": {
     "tdd-claude-code": "./bin/install.js"