@windyroad/tdd 0.1.1

package/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "wr-tdd",
+  "version": "0.1.0",
+  "description": "TDD state machine enforcement (IDLE/RED/GREEN/BLOCKED) for Claude Code"
+}

package/bin/install.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const utils = await import(resolve(__dirname, "../lib/install-utils.mjs"));
+
+const PLUGIN = "wr-tdd";
+const DEPS = [];
+
+const flags = utils.parseStandardArgs(process.argv);
+
+if (flags.help) {
+  console.log(`
+Usage: npx @windyroad/tdd [options]
+
+TDD state machine enforcement (Red-Green-Refactor cycle)
+
+Options:
+  --update     Update this plugin and its skills
+  --uninstall  Remove this plugin
+  --dry-run    Show what would be done without executing
+  --help, -h   Show this help
+`);
+  process.exit(0);
+}
+
+if (flags.dryRun) {
+  utils.setDryRun(true);
+  console.log("[dry-run mode — no commands will be executed]\n");
+}
+
+utils.checkPrerequisites();
+
+if (flags.uninstall) {
+  utils.uninstallPackage(PLUGIN);
+} else if (flags.update) {
+  utils.updatePackage(PLUGIN);
+} else {
+  utils.installPackage(PLUGIN, { deps: DEPS });
+}

package/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      { "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/tdd-inject.sh" }] }
+    ],
+    "PreToolUse": [
+      { "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/tdd-enforce-edit.sh" }] }
+    ],
+    "PostToolUse": [
+      { "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/tdd-post-write.sh" }] }
+    ],
+    "Stop": [
+      { "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/tdd-reset.sh" }] }
+    ]
+  }
+}

package/hooks/lib/tdd-gate.sh

@@ -0,0 +1,176 @@
+#!/bin/bash
+# TDD Gate - shared library for TDD enforcement hooks.
+# Sourced by tdd-inject.sh, tdd-enforce-edit.sh, tdd-post-write.sh, tdd-reset.sh.
+# Provides: tdd_classify_file, tdd_read_state, tdd_write_state, tdd_run_tests,
+#           tdd_add_test_file, tdd_get_test_files, tdd_cleanup, tdd_has_test_script,
+#           tdd_deny_json
+
+# --- Configuration ---
+TDD_TEST_CMD="${TDD_TEST_CMD:-npm test --}"
+TDD_TEST_TIMEOUT="${TDD_TEST_TIMEOUT:-30}"
+
+# --- File Classification ---
+# Returns: "test", "exempt", or "impl"
+tdd_classify_file() {
+  local FILE_PATH="$1"
+  local BASENAME
+  BASENAME=$(basename "$FILE_PATH")
+
+  # Test files (always allowed)
+  case "$BASENAME" in
+    *.test.ts|*.test.tsx|*.test.js|*.test.jsx) echo "test"; return ;;
+    *.spec.ts|*.spec.tsx|*.spec.js|*.spec.jsx) echo "test"; return ;;
+  esac
+  case "$FILE_PATH" in
+    */__tests__/*) echo "test"; return ;;
+  esac
+
+  # Exempt files (not gated)
+  case "$FILE_PATH" in
+    # Config files
+    *.config.*|*.json|*.yml|*.yaml) echo "exempt"; return ;;
+    # Module configs (*.mjs, *.cjs are config when at root or named as config)
+    *.mjs|*.cjs) echo "exempt"; return ;;
+    # Styles
+    *.css|*.scss|*.sass|*.less) echo "exempt"; return ;;
+    # Assets
+    *.png|*.jpg|*.jpeg|*.gif|*.svg|*.ico|*.webp) echo "exempt"; return ;;
+    *.woff|*.woff2|*.ttf|*.eot) echo "exempt"; return ;;
+    # Docs
+    *.md|*.mdx) echo "exempt"; return ;;
+    */docs/*|docs/*) echo "exempt"; return ;;
+    # Tooling
+    */.claude/*|.claude/*) echo "exempt"; return ;;
+    */.github/*|.github/*) echo "exempt"; return ;;
+    # Lockfiles and sourcemaps
+    *package-lock.json|*yarn.lock|*pnpm-lock.yaml) echo "exempt"; return ;;
+    *.map) echo "exempt"; return ;;
+    # Shell scripts
+    *.sh) echo "exempt"; return ;;
+  esac
+
+  # Implementation files (gated)
+  case "$BASENAME" in
+    *.ts|*.tsx|*.js|*.jsx) echo "impl"; return ;;
+  esac
+
+  # Everything else is exempt
+  echo "exempt"
+}
+
+# --- State Management ---
+# Marker files use session ID to isolate concurrent sessions
+_tdd_state_file() { echo "/tmp/tdd-state-${1}"; }
+_tdd_test_files_file() { echo "/tmp/tdd-test-files-${1}"; }
+_tdd_test_stdout_file() { echo "/tmp/tdd-test-stdout-${1}"; }
+
+# Read current state. Returns: IDLE, RED, GREEN, or BLOCKED
+tdd_read_state() {
+  local SESSION_ID="$1"
+  local STATE_FILE
+  STATE_FILE=$(_tdd_state_file "$SESSION_ID")
+  if [ -f "$STATE_FILE" ]; then
+    cat "$STATE_FILE"
+  else
+    echo "IDLE"
+  fi
+}
+
+# Write state
+tdd_write_state() {
+  local SESSION_ID="$1"
+  local NEW_STATE="$2"
+  local STATE_FILE
+  STATE_FILE=$(_tdd_state_file "$SESSION_ID")
+  echo "$NEW_STATE" > "$STATE_FILE"
+}
+
+# Track test files touched this session
+tdd_add_test_file() {
+  local SESSION_ID="$1"
+  local TEST_FILE="$2"
+  local TRACK_FILE
+  TRACK_FILE=$(_tdd_test_files_file "$SESSION_ID")
+  # Avoid duplicates
+  if [ -f "$TRACK_FILE" ] && grep -qxF "$TEST_FILE" "$TRACK_FILE" 2>/dev/null; then
+    return 0
+  fi
+  echo "$TEST_FILE" >> "$TRACK_FILE"
+}
+
+# Get all test files for this session (newline-separated)
+tdd_get_test_files() {
+  local SESSION_ID="$1"
+  local TRACK_FILE
+  TRACK_FILE=$(_tdd_test_files_file "$SESSION_ID")
+  if [ -f "$TRACK_FILE" ]; then
+    cat "$TRACK_FILE"
+  fi
+}
+
+# --- Test Runner ---
+# Runs tests for the session's tracked test files.
+# Returns: 0=pass, 1=fail, 124=timeout, other=error
+# Saves stdout to marker file for debugging.
+tdd_run_tests() {
+  local SESSION_ID="$1"
+  local STDOUT_FILE
+  STDOUT_FILE=$(_tdd_test_stdout_file "$SESSION_ID")
+  local TEST_FILES
+  TEST_FILES=$(tdd_get_test_files "$SESSION_ID")
+
+  if [ -z "$TEST_FILES" ]; then
+    echo "No test files tracked" > "$STDOUT_FILE"
+    return 0  # No tests to run = pass (no-op)
+  fi
+
+  # Build argument list from tracked test files
+  local ARGS=""
+  while IFS= read -r f; do
+    ARGS="$ARGS $f"
+  done <<< "$TEST_FILES"
+
+  # Run with timeout
+  local EXIT_CODE
+  timeout "$TDD_TEST_TIMEOUT" bash -c "$TDD_TEST_CMD $ARGS" > "$STDOUT_FILE" 2>&1
+  EXIT_CODE=$?
+
+  return $EXIT_CODE
+}
+
+# --- Prerequisite Check ---
+# Returns 0 if a test script is configured, 1 otherwise
+tdd_has_test_script() {
+  if [ -f "package.json" ]; then
+    # Check if "test" script exists and is not the default npm placeholder
+    local TEST_SCRIPT
+    TEST_SCRIPT=$(jq -r '.scripts.test // empty' package.json 2>/dev/null)
+    if [ -n "$TEST_SCRIPT" ] && [ "$TEST_SCRIPT" != "echo \"Error: no test specified\" && exit 1" ]; then
+      return 0
+    fi
+  fi
+  return 1
+}
+
+# --- Cleanup ---
+tdd_cleanup() {
+  local SESSION_ID="$1"
+  rm -f "$(_tdd_state_file "$SESSION_ID")"
+  rm -f "$(_tdd_test_files_file "$SESSION_ID")"
+  rm -f "$(_tdd_test_stdout_file "$SESSION_ID")"
+}
+
+# --- Deny Helper ---
+# Emit PreToolUse deny JSON
+tdd_deny_json() {
+  local REASON="$1"
+  cat <<EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": "$REASON"
+  }
+}
+EOF
+}

package/hooks/tdd-enforce-edit.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# TDD - PreToolUse enforcement hook (Edit|Write)
+# Blocks implementation file edits unless state is RED or GREEN.
+# Test files and exempt files are always allowed.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib/tdd-gate.sh"
+
+INPUT=$(cat)
+
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty') || true
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty') || true
+
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+# Classify first, then check test script (only impl files need gating)
+FILE_TYPE=$(tdd_classify_file "$FILE_PATH")
+if [ "$FILE_TYPE" != "impl" ]; then
+  exit 0
+fi
+
+# If no test script configured, block and direct to create skill
+if ! tdd_has_test_script; then
+  BASENAME=$(basename "$FILE_PATH")
+  tdd_deny_json "BLOCKED: Cannot edit '${BASENAME}' because no test script is configured in package.json. Run /wr-tdd:create to set up a test framework for this project. TDD enforcement requires a working test runner before implementation code can be written."
+  exit 0
+fi
+
+if [ -z "$SESSION_ID" ]; then
+  # Fail-closed: cannot check state without session ID
+  tdd_deny_json "BLOCKED: Could not determine session ID. TDD gate is fail-closed."
+  exit 0
+fi
+
+# Check state for implementation files
+STATE=$(tdd_read_state "$SESSION_ID")
+BASENAME=$(basename "$FILE_PATH")
+
+case "$STATE" in
+  RED|GREEN)
+    # Allowed: agent is in the TDD cycle
+    exit 0
+    ;;
+  IDLE)
+    tdd_deny_json "BLOCKED: Cannot edit '${BASENAME}' -- no tests written yet. TDD state is IDLE. You MUST write a failing test first (*.test.ts or *.spec.ts) before editing implementation files. The test should describe the behavior you want to implement."
+    exit 0
+    ;;
+  BLOCKED)
+    tdd_deny_json "BLOCKED: Cannot edit '${BASENAME}' -- test runner is in error state. TDD state is BLOCKED. Fix the test setup first (check test configuration, fix syntax errors in test files, or verify the test command works)."
+    exit 0
+    ;;
+  *)
+    tdd_deny_json "BLOCKED: Cannot edit '${BASENAME}' -- unknown TDD state '${STATE}'. Write a failing test first."
+    exit 0
+    ;;
+esac

package/hooks/tdd-inject.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# TDD - UserPromptSubmit hook
+# Injects TDD instructions and current state into every prompt.
+# Only active when a test script is configured in package.json.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib/tdd-gate.sh"
+
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty') || true
+
+# If no test script configured, inject setup instructions
+if ! tdd_has_test_script; then
+  cat <<'HOOK_OUTPUT'
+INSTRUCTION: MANDATORY TDD ENFORCEMENT. YOU MUST FOLLOW THIS.
+
+This project has NO test script configured in package.json. Implementation file
+edits (.ts, .tsx, .js, .jsx) are BLOCKED until testing is set up.
+
+If the user's task involves writing or editing implementation code, you MUST
+run /wr-tdd:create first to configure a test framework for this project.
+
+Test files, config files, docs, and styles are still writable.
+HOOK_OUTPUT
+  exit 0
+fi
+
+STATE="IDLE"
+if [ -n "$SESSION_ID" ]; then
+  STATE=$(tdd_read_state "$SESSION_ID")
+fi
+
+TEST_FILES=""
+if [ -n "$SESSION_ID" ]; then
+  TEST_FILES=$(tdd_get_test_files "$SESSION_ID")
+fi
+
+cat <<HOOK_OUTPUT
+INSTRUCTION: MANDATORY TDD ENFORCEMENT. YOU MUST FOLLOW THIS.
+
+This project enforces Red-Green-Refactor via hooks. Your current TDD state is: **${STATE}**
+
+STATE RULES:
+- IDLE: You MUST write a failing test FIRST before any implementation code.
+  Implementation file edits (.ts, .tsx, .js, .jsx) are BLOCKED until you write a test.
+- RED: Tests are failing. Write implementation code to make them pass.
+  Implementation file edits are ALLOWED.
+- GREEN: Tests are passing. You may refactor or write a new failing test.
+  Implementation file edits are ALLOWED.
+- BLOCKED: Test runner error or timeout. Fix the test setup before continuing.
+  Implementation file edits are BLOCKED.
+
+WORKFLOW:
+1. Write a test file (*.test.ts, *.spec.ts, etc.) that describes the desired behavior
+2. The test MUST fail (RED state) -- this proves the test is meaningful
+3. Write the minimum implementation to make the test pass (GREEN state)
+4. Refactor while keeping tests green
+5. Repeat for the next behavior
+
+IMPORTANT:
+- Test files and config/doc/style files are ALWAYS writable regardless of state
+- Implementation files are ONLY writable in RED or GREEN states
+- The hook runs your tests automatically after every file write
+- To refactor existing code, touch the relevant test file first to enter the cycle
+HOOK_OUTPUT
+
+if [ -n "$TEST_FILES" ]; then
+  echo ""
+  echo "TRACKED TEST FILES THIS SESSION:"
+  echo "$TEST_FILES" | sed 's/^/  - /'
+fi
+
+exit 0

package/hooks/tdd-post-write.sh

@@ -0,0 +1,114 @@
+#!/bin/bash
+# TDD - PostToolUse hook (Edit|Write)
+# Runs tests after file writes and transitions state.
+# Emits additionalContext with the current TDD state.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib/tdd-gate.sh"
+
+# Skip if no test script configured
+if ! tdd_has_test_script; then
+  exit 0
+fi
+
+INPUT=$(cat)
+
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty') || true
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty') || true
+
+if [ -z "$FILE_PATH" ] || [ -z "$SESSION_ID" ]; then
+  exit 0
+fi
+
+# Classify the file
+FILE_TYPE=$(tdd_classify_file "$FILE_PATH")
+
+# Skip exempt files entirely
+if [ "$FILE_TYPE" = "exempt" ]; then
+  exit 0
+fi
+
+# Track test files
+if [ "$FILE_TYPE" = "test" ]; then
+  tdd_add_test_file "$SESSION_ID" "$FILE_PATH"
+fi
+
+# Run tests
+tdd_run_tests "$SESSION_ID"
+TEST_EXIT=$?
+
+# Read current state
+OLD_STATE=$(tdd_read_state "$SESSION_ID")
+
+# Transition state based on file type + test result
+NEW_STATE="$OLD_STATE"
+
+if [ $TEST_EXIT -eq 0 ]; then
+  # Tests pass
+  NEW_STATE="GREEN"
+elif [ $TEST_EXIT -eq 1 ]; then
+  # Tests fail
+  case "$FILE_TYPE" in
+    test)
+      NEW_STATE="RED"
+      ;;
+    impl)
+      case "$OLD_STATE" in
+        RED) NEW_STATE="RED" ;;    # still working
+        GREEN) NEW_STATE="RED" ;;  # broke something
+        *) NEW_STATE="RED" ;;
+      esac
+      ;;
+  esac
+else
+  # Timeout (124) or other error
+  NEW_STATE="BLOCKED"
+fi
+
+# Write new state
+tdd_write_state "$SESSION_ID" "$NEW_STATE"
+
+# Read last test output for context
+STDOUT_FILE="/tmp/tdd-test-stdout-${SESSION_ID}"
+TEST_OUTPUT=""
+if [ -f "$STDOUT_FILE" ]; then
+  # Limit to last 50 lines to avoid flooding context
+  TEST_OUTPUT=$(tail -50 "$STDOUT_FILE")
+fi
+
+# Emit state as additionalContext
+if [ "$OLD_STATE" != "$NEW_STATE" ]; then
+  TRANSITION="State transition: ${OLD_STATE} -> ${NEW_STATE}"
+else
+  TRANSITION="State unchanged: ${NEW_STATE}"
+fi
+
+cat <<EOF
+TDD STATE UPDATE: ${TRANSITION}
+Current state: ${NEW_STATE}
+File written: ${FILE_PATH} (${FILE_TYPE})
+Test result: exit code ${TEST_EXIT}
+EOF
+
+if [ $TEST_EXIT -ne 0 ] && [ -n "$TEST_OUTPUT" ]; then
+  echo ""
+  echo "Test output (last 50 lines):"
+  echo "$TEST_OUTPUT"
+fi
+
+case "$NEW_STATE" in
+  RED)
+    echo ""
+    echo "ACTION: Tests are failing. Write implementation code to make them pass."
+    ;;
+  GREEN)
+    echo ""
+    echo "ACTION: Tests are passing. You may refactor or write a new failing test for the next behavior."
+    ;;
+  BLOCKED)
+    echo ""
+    echo "ACTION: Test runner error (exit code ${TEST_EXIT}). Fix the test setup before continuing."
+    ;;
+esac
+
+exit 0

package/hooks/tdd-reset.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# TDD - Stop hook
+# Cleans up TDD marker files when the session ends.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib/tdd-gate.sh"
+
+INPUT=$(cat)
+
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty') || true
+
+if [ -n "$SESSION_ID" ]; then
+  tdd_cleanup "$SESSION_ID"
+fi
+
+exit 0

package/lib/install-utils.mjs

@@ -0,0 +1,163 @@
+/**
+ * Shared install utilities for @windyroad/* packages.
+ * Used by both per-plugin installers and the meta-installer.
+ */
+
+import { execSync } from "node:child_process";
+
+const MARKETPLACE_REPO = "windyroad/agent-plugins";
+const MARKETPLACE_NAME = "windyroad";
+
+let _dryRun = false;
+
+export { MARKETPLACE_REPO, MARKETPLACE_NAME };
+
+export function setDryRun(value) {
+  _dryRun = value;
+}
+
+export function isDryRun() {
+  return _dryRun;
+}
+
+export function run(cmd, label) {
+  console.log(`  ${label}...`);
+  if (_dryRun) {
+    console.log(`    [dry-run] ${cmd}`);
+    return true;
+  }
+  try {
+    execSync(cmd, { stdio: "inherit" });
+    return true;
+  } catch {
+    console.error(`  FAILED: ${label}`);
+    return false;
+  }
+}
+
+export function checkPrerequisites() {
+  if (_dryRun) return;
+
+  try {
+    execSync("claude --version", { stdio: "pipe" });
+  } catch {
+    console.error(
+      "Error: 'claude' CLI not found. Install Claude Code first:\n  https://docs.anthropic.com/en/docs/claude-code\n"
+    );
+    process.exit(1);
+  }
+
+  try {
+    execSync("npx --version", { stdio: "pipe" });
+  } catch {
+    console.error(
+      "Error: 'npx' not found. Install Node.js first:\n  https://nodejs.org\n"
+    );
+    process.exit(1);
+  }
+}
+
+export function addMarketplace() {
+  return run(
+    `claude plugin marketplace add ${MARKETPLACE_REPO}`,
+    `Marketplace: ${MARKETPLACE_NAME}`
+  );
+}
+
+export function installPlugin(pluginName) {
+  return run(
+    `claude plugin install ${pluginName}@${MARKETPLACE_NAME}`,
+    pluginName
+  );
+}
+
+export function updatePlugin(pluginName) {
+  return run(`claude plugin update ${pluginName}`, pluginName);
+}
+
+export function uninstallPlugin(pluginName) {
+  return run(`claude plugin uninstall ${pluginName}`, `Removing ${pluginName}`);
+}
+
+export function installSkills() {
+  return run(
+    `npx -y skills add --yes --all ${MARKETPLACE_REPO}`,
+    "Skills (via skills package)"
+  );
+}
+
+export function updateSkills() {
+  return run("npx -y skills update", "Skills update");
+}
+
+export function removeSkills() {
+  return run(
+    `npx -y skills remove --yes --all ${MARKETPLACE_REPO}`,
+    "Removing skills"
+  );
+}
+
+/**
+ * Install a single package: marketplace add + plugin install + skills.
+ */
+export function installPackage(pluginName, { deps = [] } = {}) {
+  console.log(`\nInstalling @windyroad/${pluginName.replace("wr-", "")}...\n`);
+
+  addMarketplace();
+  installPlugin(pluginName);
+  installSkills();
+
+  if (deps.length > 0) {
+    console.log(`\nNote: This plugin works best with:`);
+    for (const dep of deps) {
+      console.log(`  - @windyroad/${dep.replace("wr-", "")} (npx @windyroad/${dep.replace("wr-", "")})`);
+    }
+  }
+
+  console.log(
+    `\nDone! Restart Claude Code to activate.\n`
+  );
+}
+
+/**
+ * Update a single package.
+ */
+export function updatePackage(pluginName) {
+  console.log(`\nUpdating @windyroad/${pluginName.replace("wr-", "")}...\n`);
+
+  run(
+    `claude plugin marketplace update ${MARKETPLACE_NAME}`,
+    "Updating marketplace"
+  );
+  updatePlugin(pluginName);
+  updateSkills();
+
+  console.log("\nDone! Restart Claude Code to apply updates.\n");
+}
+
+/**
+ * Uninstall a single package.
+ */
+export function uninstallPackage(pluginName) {
+  console.log(`\nUninstalling @windyroad/${pluginName.replace("wr-", "")}...\n`);
+
+  uninstallPlugin(pluginName);
+
+  console.log("\nDone. Restart Claude Code to apply changes.\n");
+  console.log("Note: Skills are shared across packages. Run");
+  console.log("  npx @windyroad/agent-plugins --uninstall");
+  console.log("to remove all skills.\n");
+}
+
+/**
+ * Parse standard flags used by all per-plugin installers.
+ */
+export function parseStandardArgs(argv) {
+  const args = argv.slice(2);
+  return {
+    help: args.includes("--help") || args.includes("-h"),
+    uninstall: args.includes("--uninstall"),
+    update: args.includes("--update"),
+    dryRun: args.includes("--dry-run"),
+  };
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@windyroad/tdd",
+  "version": "0.1.1",
+  "description": "TDD state machine enforcement (Red-Green-Refactor cycle)",
+  "bin": {
+    "windyroad-tdd": "./bin/install.mjs"
+  },
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/windyroad/agent-plugins.git",
+    "directory": "packages/tdd"
+  },
+  "keywords": [
+    "claude-code",
+    "claude-code-plugin",
+    "ai-agent",
+    "ai-coding"
+  ],
+  "files": [
+    "bin/",
+    "agents/",
+    "hooks/",
+    "skills/",
+    ".claude-plugin/",
+    "lib/"
+  ]
+}

package/skills/wr:tdd/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: wr:tdd
+description: Set up a test framework for the project. Examines the codebase, recommends a test runner, configures package.json, and creates an example test.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion
+---
+
+# Test Framework Setup
+
+Configure a test framework for this project so TDD enforcement can operate. The TDD hooks require a working `test` script in package.json to run the Red-Green-Refactor cycle.
+
+## Steps
+
+### 1. Discover project context
+
+Examine the project to understand what needs testing.
+
+**Find the tech stack**:
+- Read `package.json` for dependencies, devDependencies, and existing scripts
+- Check for TypeScript (`tsconfig.json`, `.ts` files)
+- Check for React/Next.js/Vue/Svelte (framework-specific testing needs)
+- Check for existing test infrastructure (vitest.config.*, jest.config.*, etc.)
+- Check for existing test files (`*.test.*`, `*.spec.*`, `__tests__/`)
+
+**Assess what exists**:
+- If test files already exist but no test script: just wire up the script
+- If a test runner is installed but not configured: configure it
+- If nothing exists: recommend a test runner and set up from scratch
+
+### 2. Choose a test runner
+
+Based on the project's stack, recommend the best test runner:
+
+| Stack | Recommended Runner | Why |
+|-------|-------------------|-----|
+| Vite/Vitest already installed | Vitest | Already in deps |
+| Next.js / React | Vitest | Fast, ESM-native, good React support |
+| TypeScript project | Vitest | No compile step needed |
+| Plain Node.js | Node.js built-in test runner | Zero dependencies |
+| Existing Jest setup | Jest | Don't switch if already configured |
+
+Prefer Vitest for most modern projects. It's fast, needs minimal config, and works with TypeScript and JSX out of the box.
+
+### 3. Confirm with the user
+
+You MUST use the AskUserQuestion tool before making changes.
+
+Present:
+1. What you found (existing test infrastructure, if any)
+2. The recommended test runner and why
+3. What files will be created/modified
+4. Whether they want an example test created
+
+### 4. Install and configure
+
+Based on user confirmation:
+
+**If Vitest:**
+```bash
+npm install -D vitest
+```
+
+Add to package.json scripts:
+```json
+"test": "vitest run"
+```
+
+Create `vitest.config.ts` if needed (minimal config, only what's required).
+
+**If Node.js built-in:**
+Add to package.json scripts:
+```json
+"test": "node --test"
+```
+
+**If Jest:**
+```bash
+npm install -D jest @types/jest ts-jest
+```
+
+Configure as needed for the project's TypeScript/JSX setup.
+
+### 5. Create example test (optional)
+
+If the user wants an example test, create one that:
+- Tests an existing function or component in the project
+- Follows the project's file structure conventions
+- Demonstrates the testing pattern (describe/it/expect)
+- Is intentionally minimal (the user will write real tests)
+
+Place it next to the source file it tests, using the `.test.ts` or `.test.tsx` convention.
+
+### 6. Verify
+
+Run the test command to confirm it works:
+```bash
+npm test
+```
+
+If it fails, diagnose and fix the configuration. The test script must work before TDD enforcement can operate.
+
+### 7. Report
+
+Tell the user:
+- What was installed and configured
+- How to run tests (`npm test`)
+- That TDD enforcement is now active (implementation edits require tests first)
+- The Red-Green-Refactor workflow they'll follow
+
+$ARGUMENTS