specweave 0.3.13 → 0.4.1

package/src/commands/specweave.tdd-red.md

@@ -0,0 +1,135 @@
+Write comprehensive failing tests following TDD red phase principles.
+
+[Extended thinking: Generates failing tests that properly define expected behavior using test-automator agent.]
+
+## Role
+
+Generate failing tests using Task tool with subagent_type="unit-testing::test-automator".
+
+## Prompt Template
+
+"Generate comprehensive FAILING tests for: $ARGUMENTS
+
+## Core Requirements
+
+1. **Test Structure**
+   - Framework-appropriate setup (Jest/pytest/JUnit/Go/RSpec)
+   - Arrange-Act-Assert pattern
+   - should_X_when_Y naming convention
+   - Isolated fixtures with no interdependencies
+
+2. **Behavior Coverage**
+   - Happy path scenarios
+   - Edge cases (empty, null, boundary values)
+   - Error handling and exceptions
+   - Concurrent access (if applicable)
+
+3. **Failure Verification**
+   - Tests MUST fail when run
+   - Failures for RIGHT reasons (not syntax/import errors)
+   - Meaningful diagnostic error messages
+   - No cascading failures
+
+4. **Test Categories**
+   - Unit: Isolated component behavior
+   - Integration: Component interaction
+   - Contract: API/interface contracts
+   - Property: Mathematical invariants
+
+## Framework Patterns
+
+**JavaScript/TypeScript (Jest/Vitest)**
+- Mock dependencies with `vi.fn()` or `jest.fn()`
+- Use `@testing-library` for React components
+- Property tests with `fast-check`
+
+**Python (pytest)**
+- Fixtures with appropriate scopes
+- Parametrize for multiple test cases
+- Hypothesis for property-based tests
+
+**Go**
+- Table-driven tests with subtests
+- `t.Parallel()` for parallel execution
+- Use `testify/assert` for cleaner assertions
+
+**Ruby (RSpec)**
+- `let` for lazy loading, `let!` for eager
+- Contexts for different scenarios
+- Shared examples for common behavior
+
+## Quality Checklist
+
+- Readable test names documenting intent
+- One behavior per test
+- No implementation leakage
+- Meaningful test data (not 'foo'/'bar')
+- Tests serve as living documentation
+
+## Anti-Patterns to Avoid
+
+- Tests passing immediately
+- Testing implementation vs behavior
+- Complex setup code
+- Multiple responsibilities per test
+- Brittle tests tied to specifics
+
+## Edge Case Categories
+
+- **Null/Empty**: undefined, null, empty string/array/object
+- **Boundaries**: min/max values, single element, capacity limits
+- **Special Cases**: Unicode, whitespace, special characters
+- **State**: Invalid transitions, concurrent modifications
+- **Errors**: Network failures, timeouts, permissions
+
+## Output Requirements
+
+- Complete test files with imports
+- Documentation of test purpose
+- Commands to run and verify failures
+- Metrics: test count, coverage areas
+- Next steps for green phase"
+
+## Validation
+
+After generation:
+1. Run tests - confirm they fail
+2. Verify helpful failure messages
+3. Check test independence
+4. Ensure comprehensive coverage
+
+## Example (Minimal)
+
+```typescript
+// auth.service.test.ts
+describe('AuthService', () => {
+  let authService: AuthService;
+  let mockUserRepo: jest.Mocked<UserRepository>;
+
+  beforeEach(() => {
+    mockUserRepo = { findByEmail: jest.fn() } as any;
+    authService = new AuthService(mockUserRepo);
+  });
+
+  it('should_return_token_when_valid_credentials', async () => {
+    const user = { id: '1', email: 'test@example.com', passwordHash: 'hashed' };
+    mockUserRepo.findByEmail.mockResolvedValue(user);
+
+    const result = await authService.authenticate('test@example.com', 'pass');
+
+    expect(result.success).toBe(true);
+    expect(result.token).toBeDefined();
+  });
+
+  it('should_fail_when_user_not_found', async () => {
+    mockUserRepo.findByEmail.mockResolvedValue(null);
+
+    const result = await authService.authenticate('none@example.com', 'pass');
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('INVALID_CREDENTIALS');
+  });
+});
+```
+
+Test requirements: $ARGUMENTS

package/src/commands/specweave.tdd-refactor.md

@@ -0,0 +1,165 @@
+Refactor code with confidence using comprehensive test safety net:
+
+[Extended thinking: This tool uses the tdd-orchestrator agent (opus model) for sophisticated refactoring while maintaining all tests green. It applies design patterns, improves code quality, and optimizes performance with the safety of comprehensive test coverage.]
+
+## Usage
+
+Use Task tool with subagent_type="tdd-orchestrator" to perform safe refactoring.
+
+Prompt: "Refactor this code while keeping all tests green: $ARGUMENTS. Apply TDD refactor phase:
+
+## Core Process
+
+**1. Pre-Assessment**
+- Run tests to establish green baseline
+- Analyze code smells and test coverage
+- Document current performance metrics
+- Create incremental refactoring plan
+
+**2. Code Smell Detection**
+- Duplicated code → Extract methods/classes
+- Long methods → Decompose into focused functions
+- Large classes → Split responsibilities
+- Long parameter lists → Parameter objects
+- Feature Envy → Move methods to appropriate classes
+- Primitive Obsession → Value objects
+- Switch statements → Polymorphism
+- Dead code → Remove
+
+**3. Design Patterns**
+- Apply Creational (Factory, Builder, Singleton)
+- Apply Structural (Adapter, Facade, Decorator)
+- Apply Behavioral (Strategy, Observer, Command)
+- Apply Domain (Repository, Service, Value Objects)
+- Use patterns only where they add clear value
+
+**4. SOLID Principles**
+- Single Responsibility: One reason to change
+- Open/Closed: Open for extension, closed for modification
+- Liskov Substitution: Subtypes substitutable
+- Interface Segregation: Small, focused interfaces
+- Dependency Inversion: Depend on abstractions
+
+**5. Refactoring Techniques**
+- Extract Method/Variable/Interface
+- Inline unnecessary indirection
+- Rename for clarity
+- Move Method/Field to appropriate classes
+- Replace Magic Numbers with constants
+- Encapsulate fields
+- Replace Conditional with Polymorphism
+- Introduce Null Object
+
+**6. Performance Optimization**
+- Profile to identify bottlenecks
+- Optimize algorithms and data structures
+- Implement caching where beneficial
+- Reduce database queries (N+1 elimination)
+- Lazy loading and pagination
+- Always measure before and after
+
+**7. Incremental Steps**
+- Make small, atomic changes
+- Run tests after each modification
+- Commit after each successful refactoring
+- Keep refactoring separate from behavior changes
+- Use scaffolding when needed
+
+**8. Architecture Evolution**
+- Layer separation and dependency management
+- Module boundaries and interface definition
+- Event-driven patterns for decoupling
+- Database access pattern optimization
+
+**9. Safety Verification**
+- Run full test suite after each change
+- Performance regression testing
+- Mutation testing for test effectiveness
+- Rollback plan for major changes
+
+**10. Advanced Patterns**
+- Strangler Fig: Gradual legacy replacement
+- Branch by Abstraction: Large-scale changes
+- Parallel Change: Expand-contract pattern
+- Mikado Method: Dependency graph navigation
+
+## Output Requirements
+
+- Refactored code with improvements applied
+- Test results (all green)
+- Before/after metrics comparison
+- Applied refactoring techniques list
+- Performance improvement measurements
+- Remaining technical debt assessment
+
+## Safety Checklist
+
+Before committing:
+- ✓ All tests pass (100% green)
+- ✓ No functionality regression
+- ✓ Performance metrics acceptable
+- ✓ Code coverage maintained/improved
+- ✓ Documentation updated
+
+## Recovery Protocol
+
+If tests fail:
+- Immediately revert last change
+- Identify breaking refactoring
+- Apply smaller incremental changes
+- Use version control for safe experimentation
+
+## Example: Extract Method Pattern
+
+**Before:**
+```typescript
+class OrderProcessor {
+  processOrder(order: Order): ProcessResult {
+    // Validation
+    if (!order.customerId || order.items.length === 0) {
+      return { success: false, error: "Invalid order" };
+    }
+
+    // Calculate totals
+    let subtotal = 0;
+    for (const item of order.items) {
+      subtotal += item.price * item.quantity;
+    }
+    let total = subtotal + (subtotal * 0.08) + (subtotal > 100 ? 0 : 15);
+
+    // Process payment...
+    // Update inventory...
+    // Send confirmation...
+  }
+}
+```
+
+**After:**
+```typescript
+class OrderProcessor {
+  async processOrder(order: Order): Promise<ProcessResult> {
+    const validation = this.validateOrder(order);
+    if (!validation.isValid) return ProcessResult.failure(validation.error);
+
+    const orderTotal = OrderTotal.calculate(order);
+    const inventoryCheck = await this.inventoryService.checkAvailability(order.items);
+    if (!inventoryCheck.available) return ProcessResult.failure(inventoryCheck.reason);
+
+    await this.paymentService.processPayment(order.paymentMethod, orderTotal.total);
+    await this.inventoryService.reserveItems(order.items);
+    await this.notificationService.sendOrderConfirmation(order, orderTotal);
+
+    return ProcessResult.success(order.id, orderTotal.total);
+  }
+
+  private validateOrder(order: Order): ValidationResult {
+    if (!order.customerId) return ValidationResult.invalid("Customer ID required");
+    if (order.items.length === 0) return ValidationResult.invalid("Order must contain items");
+    return ValidationResult.valid();
+  }
+}
+```
+
+**Applied:** Extract Method, Value Objects, Dependency Injection, Async patterns
+
+Code to refactor: $ARGUMENTS"

package/src/hooks/post-increment-plugin-detect.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+
+#
+# Post-Increment Plugin Detection Hook (T-021)
+#
+# Runs AFTER increment completion to suggest plugins based on git diff
+# This is Phase 4 of the 4-phase plugin detection system
+#
+# Trigger: After `/specweave.done` completes an increment
+# Output: Plugin suggestions for NEXT increment
+#
+
+# Exit on error
+set -e
+
+# Get project root (assumes hook runs from project directory)
+PROJECT_ROOT=$(pwd)
+
+# Colors for output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+GRAY='\033[0;37m'
+MAGENTA='\033[0;35m'
+NC='\033[0m' # No Color
+
+# Check if SpecWeave is installed
+if ! command -v specweave &> /dev/null; then
+    # Silent exit if SpecWeave not installed (development mode)
+    exit 0
+fi
+
+# Check if git repository exists
+if [ ! -d ".git" ]; then
+    # Not a git repo, skip detection
+    exit 0
+fi
+
+# Get completed increment number (passed as argument)
+INCREMENT_NUM="$1"
+
+if [ -z "$INCREMENT_NUM" ]; then
+    # No increment number provided, skip
+    exit 0
+fi
+
+# Get git diff since last increment tag (or HEAD if no tags)
+LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "HEAD~10")
+GIT_DIFF=$(git diff --name-only "$LAST_TAG"..HEAD 2>/dev/null || echo "")
+
+if [ -z "$GIT_DIFF" ]; then
+    # No changes detected, skip
+    exit 0
+fi
+
+# Also check package.json changes for new dependencies
+PACKAGE_JSON_CHANGED=false
+if echo "$GIT_DIFF" | grep -q "package.json"; then
+    PACKAGE_JSON_CHANGED=true
+fi
+
+# Keyword-based plugin detection from file changes
+declare -A PLUGIN_PATTERNS=(
+    ["specweave-github"]=".github/|github-"
+    ["specweave-kubernetes"]="kubernetes/|k8s/|helm/|\.yaml$"
+    ["specweave-frontend-stack"]="components/|pages/|app/|\.tsx$|\.jsx$"
+    ["specweave-backend-stack"]="api/|server/|routes/|controllers/"
+    ["specweave-ml-ops"]="models/|training/|\.ipynb$|\.h5$|\.pkl$"
+    ["specweave-payment-processing"]="payments/|billing/|stripe"
+    ["specweave-figma"]="\.figma|design/|mockups/"
+    ["specweave-observability"]="prometheus/|grafana/|monitoring/"
+    ["specweave-diagrams"]="diagrams/|\.mmd$|architecture/"
+)
+
+# Dependency-based detection (if package.json changed)
+declare -A DEPENDENCY_PLUGINS=(
+    ["specweave-frontend-stack"]="react|vue|angular|next"
+    ["specweave-backend-stack"]="express|fastapi|django|nestjs"
+    ["specweave-payment-processing"]="stripe|paypal"
+    ["specweave-ml-ops"]="tensorflow|pytorch|scikit-learn"
+    ["specweave-observability"]="prometheus-client|@opentelemetry"
+)
+
+# Detect plugins based on file patterns
+SUGGESTED_PLUGINS=()
+
+# Check file patterns
+for plugin in "${!PLUGIN_PATTERNS[@]}"; do
+    pattern="${PLUGIN_PATTERNS[$plugin]}"
+
+    if echo "$GIT_DIFF" | grep -qi -E "$pattern"; then
+        # Check if plugin is already enabled
+        if ! specweave plugin list --enabled 2>/dev/null | grep -q "$plugin"; then
+            if [[ ! " ${SUGGESTED_PLUGINS[@]} " =~ " ${plugin} " ]]; then
+                SUGGESTED_PLUGINS+=("$plugin")
+            fi
+        fi
+    fi
+done
+
+# Check package.json dependencies if it changed
+if [ "$PACKAGE_JSON_CHANGED" = true ] && [ -f "package.json" ]; then
+    DEPENDENCIES=$(cat package.json | grep -A 100 '"dependencies"' | grep -A 100 '"devDependencies"' || echo "")
+
+    for plugin in "${!DEPENDENCY_PLUGINS[@]}"; do
+        keywords="${DEPENDENCY_PLUGINS[$plugin]}"
+
+        if echo "$DEPENDENCIES" | grep -qi -E "$keywords"; then
+            if ! specweave plugin list --enabled 2>/dev/null | grep -q "$plugin"; then
+                if [[ ! " ${SUGGESTED_PLUGINS[@]} " =~ " ${plugin} " ]]; then
+                    SUGGESTED_PLUGINS+=("$plugin")
+                fi
+            fi
+        fi
+    done
+fi
+
+# Output suggestions if any found
+if [ ${#SUGGESTED_PLUGINS[@]} -gt 0 ]; then
+    echo ""
+    echo -e "${MAGENTA}══════════════════════════════════════════════════════${NC}"
+    echo -e "${CYAN}💡 Plugin Suggestions for Next Increment${NC}"
+    echo -e "${MAGENTA}══════════════════════════════════════════════════════${NC}"
+    echo ""
+    echo -e "${GRAY}Increment ${INCREMENT_NUM} introduced changes that suggest:${NC}"
+    echo ""
+
+    for plugin in "${SUGGESTED_PLUGINS[@]}"; do
+        echo -e "   ✨ ${GREEN}${plugin}${NC}"
+    done
+
+    echo ""
+    echo -e "${YELLOW}Consider enabling these plugins for your next increment:${NC}"
+    echo -e "${CYAN}   specweave plugin enable <name>${NC}"
+    echo ""
+    echo -e "${GRAY}Plugins will auto-activate skills and agents for better support${NC}"
+    echo -e "${MAGENTA}══════════════════════════════════════════════════════${NC}"
+    echo ""
+fi
+
+# Always exit successfully (non-blocking)
+exit 0

package/src/hooks/post-task-completion.sh

@@ -4,9 +4,10 @@
 # Runs automatically after ANY task is marked complete via TodoWrite
 #
 # Actions:
-# 1. Play completion sound (synchronously, not background)
-# 2. Output JSON systemMessage reminding to update docs
-# 3. Log completion
+# 1. Check if ALL tasks are completed (parse stdin JSON)
+# 2. Play completion sound ONLY if all tasks done
+# 3. Output JSON systemMessage reminding to update docs
+# 4. Log completion
 #
 # DEBOUNCING: Prevents rapid duplicate fires (Claude Code calls hooks twice)
 
@@ -42,16 +43,43 @@ fi
 # Save current timestamp
 echo "$CURRENT_TIME" > "$LAST_FIRE_FILE"
 
+# Read stdin to temporary file
+STDIN_DATA=$(mktemp)
+cat > "$STDIN_DATA"
+
 # DEBUG: Log hook invocation
 echo "[$(date)] Hook invoked! PWD=$PWD Args=$*" >> .specweave/logs/hooks-debug.log 2>/dev/null || true
 echo "[$(date)] Hook stdin:" >> .specweave/logs/hooks-debug.log 2>/dev/null || true
-cat >> .specweave/logs/hooks-debug.log 2>/dev/null || true
+cat "$STDIN_DATA" >> .specweave/logs/hooks-debug.log 2>/dev/null || true
+
+# Parse JSON to check if ALL tasks are completed
+# Extract todos array and check for any non-completed tasks
+ALL_COMPLETED=false
+
+if command -v jq >/dev/null 2>&1; then
+  # Use jq if available (more reliable)
+  PENDING_COUNT=$(jq -r '.tool_input.todos // [] | map(select(.status != "completed")) | length' "$STDIN_DATA" 2>/dev/null || echo "1")
+
+  if [ "$PENDING_COUNT" = "0" ]; then
+    ALL_COMPLETED=true
+  fi
+else
+  # Fallback: Simple grep check (less reliable but works without jq)
+  if grep -q '"status":"pending"\|"status":"in_progress"' "$STDIN_DATA" 2>/dev/null; then
+    ALL_COMPLETED=false
+  else
+    # No pending/in_progress found - likely all completed
+    ALL_COMPLETED=true
+  fi
+fi
 
-# 1. Play notification sound SYNCHRONOUSLY (cross-platform)
+# Clean up temp file
+rm -f "$STDIN_DATA"
+
+# 1. Play notification sound ONLY if ALL tasks are completed
 play_sound() {
   case "$(uname -s)" in
     Darwin)
-      # Play synchronously (remove &)
       afplay /System/Library/Sounds/Glass.aiff 2>/dev/null || true
       ;;
     Linux)
@@ -64,16 +92,30 @@ play_sound() {
   esac
 }
 
-# Play sound FIRST (synchronously)
-play_sound
+# Play sound ONLY if all tasks completed
+if [ "$ALL_COMPLETED" = "true" ]; then
+  echo "[$(date)] 🎉 ALL TASKS COMPLETED - Playing sound!" >> .specweave/logs/hooks-debug.log 2>/dev/null || true
+  play_sound
+else
+  echo "[$(date)] Task completed, but more tasks remain (no sound)" >> .specweave/logs/hooks-debug.log 2>/dev/null || true
+fi
 
 # 2. Log completion
-echo "[$(date)] Task completed" >> .specweave/logs/tasks.log 2>/dev/null || true
+echo "[$(date)] Task completed (All done: $ALL_COMPLETED)" >> .specweave/logs/tasks.log 2>/dev/null || true
 
 # 3. Output JSON to instruct Claude (systemMessage is shown to user)
-cat <<EOF
+if [ "$ALL_COMPLETED" = "true" ]; then
+  cat <<EOF
 {
   "continue": true,
-  "systemMessage": "🔔 Task completed! Remember to update documentation with inline edits to CLAUDE.md and README.md as needed."
+  "systemMessage": "🎉 ALL TASKS COMPLETED! Remember to update documentation with inline edits to CLAUDE.md and README.md as needed."
 }
 EOF
+else
+  cat <<EOF
+{
+  "continue": true,
+  "systemMessage": "✅ Task completed. More tasks remaining - keep going!"
+}
+EOF
+fi

package/src/hooks/pre-task-plugin-detect.sh

@@ -0,0 +1,96 @@
+#!/bin/bash
+
+#
+# Pre-Task Plugin Detection Hook (T-020)
+#
+# Runs BEFORE task execution to suggest plugins based on task description
+# This is Phase 3 of the 4-phase plugin detection system
+#
+# Trigger: Before executing any task via `/specweave.do`
+# Output: Non-blocking plugin suggestions
+#
+
+# Exit on error
+set -e
+
+# Get project root (assumes hook runs from project directory)
+PROJECT_ROOT=$(pwd)
+
+# Colors for output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+GRAY='\033[0;37m'
+NC='\033[0m' # No Color
+
+# Check if SpecWeave is installed
+if ! command -v specweave &> /dev/null; then
+    # Silent exit if SpecWeave not installed (development mode)
+    exit 0
+fi
+
+# Get current task being executed (passed as argument)
+TASK_FILE="$1"
+
+if [ -z "$TASK_FILE" ] || [ ! -f "$TASK_FILE" ]; then
+    # No task file provided, skip detection
+    exit 0
+fi
+
+# Extract task description
+TASK_DESCRIPTION=$(grep -A 5 "^### T-[0-9]" "$TASK_FILE" | head -1 || echo "")
+
+if [ -z "$TASK_DESCRIPTION" ]; then
+    # No description found, skip
+    exit 0
+fi
+
+# Keyword-based plugin detection
+declare -A PLUGIN_KEYWORDS=(
+    ["specweave-github"]="github|gh|issue|pull request|pr"
+    ["specweave-kubernetes"]="kubernetes|k8s|kubectl|helm|pod|deployment"
+    ["specweave-frontend-stack"]="react|vue|angular|nextjs|frontend|ui|component"
+    ["specweave-backend-stack"]="express|fastapi|django|flask|nestjs|backend|api|server"
+    ["specweave-ml-ops"]="tensorflow|pytorch|sklearn|ml|machine learning|model|training"
+    ["specweave-payment-processing"]="stripe|paypal|payment|billing|subscription"
+    ["specweave-figma"]="figma|design|mockup|prototype"
+    ["specweave-jira"]="jira|atlassian|ticket"
+    ["specweave-observability"]="prometheus|grafana|datadog|monitoring|metrics|tracing"
+)
+
+# Detect plugins based on keywords
+SUGGESTED_PLUGINS=()
+
+for plugin in "${!PLUGIN_KEYWORDS[@]}"; do
+    keywords="${PLUGIN_KEYWORDS[$plugin]}"
+
+    # Check if any keyword matches (case-insensitive)
+    if echo "$TASK_DESCRIPTION" | grep -qi -E "$keywords"; then
+        # Check if plugin is already enabled
+        if ! specweave plugin list --enabled 2>/dev/null | grep -q "$plugin"; then
+            SUGGESTED_PLUGINS+=("$plugin")
+        fi
+    fi
+done
+
+# Output suggestions if any found
+if [ ${#SUGGESTED_PLUGINS[@]} -gt 0 ]; then
+    echo ""
+    echo -e "${CYAN}💡 Plugin Detection${NC}"
+    echo ""
+    echo -e "${GRAY}Task mentions: ${TASK_DESCRIPTION}${NC}"
+    echo ""
+    echo -e "${YELLOW}Suggested plugins:${NC}"
+
+    for plugin in "${SUGGESTED_PLUGINS[@]}"; do
+        echo -e "   • ${GREEN}${plugin}${NC}"
+    done
+
+    echo ""
+    echo -e "${GRAY}This task might benefit from these plugins.${NC}"
+    echo -e "${GRAY}Run: ${CYAN}specweave plugin enable <name>${GRAY} to install${NC}"
+    echo ""
+fi
+
+# Always exit successfully (non-blocking)
+exit 0